What are the applied effects?

Question

What is the meaning of the concept of effect with effective applicative programming?

For example, which parts of the expressions below are effects?

[(+1)] <*> [2,3] Just (+1) <*> Nothing 

Answer 1

A lot of confusion was caused by the poor choice of names, as is quite common in Haskell (think of " return ", much better called " emit ").

pure x not pure, it x is pure, pure simply entered. This was supposed to be used in the template pure f <*> a <*> b <*> ... , allowing us to efficiently apply the pure function f .

You can imagine an attractive appeal that sends a scream to the city gate to proclaim every value that it receives (with pure ), and whose example ( <*> ) proclaims each result obtained; then pure x simply means the x that was shouted at at the city gates. The effect is crying, so pure x will be the effective value of x . And we can write (roughly) this, as simple as pure x , in our pure language.

[] applicative method allows us to "non-deterministically" apply ( <*> , not $ ) a non-deterministic value (rather than two values ​​in your example) a deterministic function; non - determinism is an effect.

In the application of the list [(+1), (+2)] there is a non-deterministic function that can increase the value by 1, and can also increase it by 2. [3,4,5] is a non-deterministic value, the possible values ​​of which are listed. Just like we usually use ordinary objects (+1) and 3 , like (+1) $ 3 , so we can use non-deterministic values ​​like determinations like [(+1)] <*> [3] or [(+1),(+2)] <*> [3,4,5] .

And with Maybe effect of failure is the effect.

Answer 2

In the FP world, an effect is any type constructor, such as Maybe , [] , IO , etc. Effects should not be confused with side effects. Intuitively, the effect is an additional property of the value that you calculate. Maybe Int means that your program computes Int with a crash effect, or [Int] means your program computes Int , but with no deterministic effect (here a non-deterministic result is modeled as a list of possible results).

Starting from here, we have the terms applicative effects and monadic effects, which mean that these effects have instances of Applicative and Monad .

I can not find any authoritative information for this, this is what I have learned from my experience.

Answer 3

We can say that an effect of type fa is all that cannot be written as pure x where x :: a .

In the application [] , pure x = [x] , so [(+1)] = pure (+1) should probably not be considered an effect. Similarly in the Maybe pure = Just application, therefore Just (+1) not an effect.

This leaves [2,3] and Nothing as effects in your respective examples. This makes an intuitive sense from the point of view that [] denotes non-deterministic calculations: [2,3] non-deterministically chooses between 2 and 3; and the prospect that Maybe stands for failed calculations: Nothing does not perform calculations.

In the definition I used, the effect (perhaps a “side effect” would be a better word) is something that cannot be written as pure x — it's just a twist so that your question is accurate and does not represent some kind of consensus or standard definition. Whether Ness answers , gives another perspective that pure generates an efficient calculation from a pure value that has a good mathematical ring for it - that is, this definition is probably easier to use in fine-tuning.

Answer 4

Effective application programming can be seen as accepting regular inefficient computing and adding effects to them. They are implemented as Applicative instances. Thus, although Int is a regular value, A Int is Int with some effect A , and A is an Applicative instance.

Consider this expression:

 x + y :: Int 

This expression is ineffective; it deals only with regular, equal values, so to speak. But we can also have an effective supplement.

One effect is failure; calculation may fail or succeed. If this fails, then the calculation stops. This is just a Maybe type.

 Just (+1) <*> Nothing :: Maybe Int 

Besides the usual values, you just add numbers together. But now we have an addition that may fail. Therefore, we must add the numbers together, provided that the calculation did not work. In this expression, we see that the calculation will fail because the second operand is Nothing .

If your calculations may fail for more than one reason, you may want to receive error messages that report a failure. Then you can use the error effect, which can be represented as something like an Either String ( String is a type of error message). The implementation of this Applicative behaves similarly to Maybe Applicative .

Another example of an effect is parsing. Analysis can be implemented by using designers and ensuring their effectiveness. Suppose you want to implement a simple arithmetic language with addition and multiplication. This could be your abstract syntax tree (AST):

 data Exp = Num Int | Var String data AST = Add Exp Exp | Multiply Exp Exp 

You create an AST simply using these constructors. But the problem is that you also need to actually parse the text, so what about the parsing act? How about tracking how much text you spent? What if parsing fails because the text does not match your grammar? Well, in libraries like Parsec , this is a parsing effect. You are using some Parse data type (this is an Applicative instance) and take constructors to the efficient world of Parse AST . Now you can build an AST by actually parsing the text, because parsing is an effect added to the AST construct.

Note that the Parse type was more complex than the Maybe and Either String instances; the parser has the effect of tracking the state, for example, how much input text is consumed and the parsing failed, which would give an error message. Applicative effects can be composed together.