do-notation | : arrow_left : Do notation for Fantasy Land monad | Functional Programming library

Sure, you can use ContT, and as Carl pointed out in the comments, your Trampoline is a specialisation of Free, so we can reuse its Monad instance, or you can write the instances for your Trampoline yourself.

Each sumArray invocation returns a state monad holding the sum of given Int array values.

No, it doesn't return "a state monad", and it doesn't hold the sum of the array.

It returns a State Int Unit value, which represents a "stateful computation of a Unit" (using an Int for the state). To get the sum, you actually have to run that computation:

Evaluating the tests within guards can’t have any side-effects — unlike in procedural languages. So the order of evaluating the comparisons or Boolean connectives doesn’t make any difference to the semantics of the program.

Prioritising the branches — that is, each of the lines starting | — is from top to bottom. But really ‘evaluating’ is the wrong concept: it would be OK for the compiler to first evaluate your b1 == False, providing it didn’t take the third branch until it had checked the first two. (GHC doesn’t actually do that; I’m just setting up a straw man.)

Note that in a call to someFunc, the arguments for b1, b2 might be arbitrarily complex expressions. Haskell’s ‘Lazy semantics’ mean that neither of them are evaluated until needed.

Does this logic always hold?

Be careful: if an early guard turns out False, you can’t assume anything about the expressions in it. The compiler might have rearranged them for efficiency, evaluated one out of textual order, then moved on. In your example, if for the first branch it turned out b1 /= True, the compiler might not evaluate b2 at all. So you can’t conclude anything about b2. Indeed b2 might give bottom/infinite calculation, if evaluated.

It’s not just with Monads or Do-notation (which are the same thing) that expressions are not necessarily evaluated in textual order — that’s true across any expressions in any context. (The IO Monad has some dodgy semantics, to make it seem ‘statements’ are executed top-to-bottom.)

When you already have Arbitrary instances for all the constituent types of a complex type (in this case Date, Activity, etc.), you don't have to do much.

Due to built-in Arbitrary instances of lists, tuples, etc., you can simply define the composed Arbitrary instance like this:

Here's an example of non-monad which fails associativity:

You can use the immutagen library to write monadic code using generators.

You can recurse while keeping around the list of already-placed queens:

There's a for comprehension construct in vavr that you could use for your use case. It helps you transform multiple Iterable, Option, Try, Future or List instances to another Iterator, Option, Try, Future or List instance respectively, by combining them (as rows of their cartesian product) into result values.

In your case, Either being an Iterator on the right value, you can use the For construct for Iterables to construct a Tuple3 of the String right values, and iterate over the resulting Iterator by invoking your side-effecting code, or mapping/transforming them in whatever way you want. You will have a rich vavr Iterator, so that's a lot more flexible than a simple JDK Iterator.

As you probably now underestand from the other answers, the problem with your approach was that even though you were using the counter, you were still generating your labels locally. In particular