Template Haskell library for writing monadic expressions more easily https://github.com/dramforever/each#readme

Latest on Hackage:

This package is not currently in any snapshots. If you're interested in using it, we recommend adding it to Stackage Nightly. Doing so will make builds more reliable, and allow stackage.org to host generated Haddocks.

BSD3 licensed by dramforever
Maintained by dramforever@live.com


Inspired by the Scala library of the same name, each is a Template Haskell library that transforms expressions containing invocations of impure subexpressions into do-notation. Just mark your impure subexpressions with bind or ~! and they will be called appropriately, as in this small demo:

ghci> $(each [| "Hello, " ++ (~! getLine) |])
World              <--[keyboard input]
"Hello, World"

With the ApplicativeDo GHC extension, calls to fmap and <*> will be arranged so that you don't need to worry if you use, say, Haxl and needs Applicative for parallelism.

Most constructs where this would make things much more simpler are already supported. In particular, these are okay:

  • Nested binds.
  • Branching constructs, even if the branches themselves uses bind. The generated do-notation will generally match imperative intuition.

These are some quirks:

  • let expressions are evaluated sequentially. each currently lacks support for detecting pure let expressions.
  • where is not implemented.
  • Parameters to lambda functions may not be used impurely. This is acceptable, but the error message may be confusing:
    ghci> $(each [| (\x -> bind x) |])

    <interactive>:25:3: error:
    • The exact Name ‘x_acBv’ is not in scope
    Probable cause: you used a unique Template Haskell name (NameU),
    perhaps via newName, but did not bind it
    If that's it, then -ddump-splices might be useful
    • In the untyped splice: $(each [| (\ x -> bind x) |])

Also, binds in the lambda will be run when the lambda is constructed, not when it's called. - PatternGuard, LambdaCase and a few other extensions (uncertain) are not yet implemented.

If you find something wrong, or really want some feature, feel free to leave an issue.

How it works

The basic structure of an each block is this:

$(each [| ... |])

Inside of this block, three (interchangable) ways are used to mark impure subexpressions:

  • bind expr
  • bind $ expr
  • (~! expr)

do-notation is generated according to left-to-right order, and branching is handled.

More demos

A more detailed demo:

ghci> :{
    | $(each [|
    |   "Hey it works"
    |   ++ show (length $
    |     "something"
    |     ++ (~! readFile "/etc/issue")
    |     ++ (~! readFile "/etc/issue.net"))
    | |])
    | :}
"Hey it works64"

Nested binds also work as expected.

ghci> prompt str = putStrLn str *> getLine
ghci> $(each [| "Nah just " ++ (~! prompt ("What's " ++ bind getLine ++ "?")) |])
something          <--[keyboard input]
What's something?
nothing            <--[keyboard input]
"Nah just nothing"
Depends on 3 packages:
Used by 1 package:
comments powered byDisqus