monads | Type safe Option , Result , and Either types | Functional Programming library

Hints:

• There's a typo in the type of g in the comment (EDIT: now fixed)
• What's the type of the hole ???? (see more details below)
• Another way is to implement iap using imap and ibind, the same way you can implement (<*>) using fmap and (>>=)
• Tactic is a more indexed version of the continuation monad type Cont r a = (a -> r) -> r, so if you're familiar with that, the implementation is the same.

You can do type-driven programming by putting a hole _ and by looking at the error message from the compiler.

There's nothing built-in, everything is a simple consequence of the Monad instance you quoted (and, since this example uses do notation, how that desugars to uses of the >>= operator):

Now you have cmd' of type Console (MaybeT IO a), and want to pass it to a function taking Console (IO a). The first thing you can do is to run the MaybeT monad inside Console and get Console (IO (Maybe a)). You can do this by fmapping runMaybeT.

Once you got Console (IO (Maybe a)), you can pass it to runConsole and get IO (Maybe a). Now, you can lift it to MaybeT IO a using MaybeT.

So it'll be something like this.

I don't think I can answer everything you asked, but I'll do my best for the parts that I do know how to answer.

What is the recommended way to implement non-IO monad comprehensions in Arrow without making all functions into suspend functions? Or is this actually the way to go?

you can use nullable.eager and either.eager respectively for pure code. Using nullable/either (without .eager) allows you to call suspend functions inside. Using eager means you can only call non-suspend functions. (not all effectual functions in kotlin are marked suspend)

Second: If in addition to non-IO monads (nullable, reader, etc.), I want to have IO - say, reading in a file and parsing it - how would i combine these two effects? Is it correct to say that there would be multiple suspend scopes corresponding to the different monads involved, and I would need to somehow nest these scopes, like I would stack monad transformers in Haskell?

You can use extension functions to emulate Reader. For example:

In Haskell, all you have to do is to create the mutable variable (actually, a reference to that) in the outer scope and use it in the inner scope.

Here I used the ST s monad to illustrate the principle, but you can do the same with IO and many other kinds of references.

Let's start with the troublesome equation and systematically substitute the definitions, working it inside-out:

You could write an idempotent wrapper around some inner type:

I hope you don't mind if I use this opportunity to do a quick tutorial on how to improve your question. It not only increases the chances of someone answering, but also might help you to find the solution yourself.

There are a couple of problems with the code you submitted, and I mean problems in terms of being a question on SO. Perhaps someone might have a ready answer just by looking at it, but let's say they don't, and they want to try it out in a worksheet. Turns out, your code has a lot of unnecessary stuff and doesn't compile.

Here are some steps you could take to make it better:

• Strip away the unnecessary custom dependencies like Employee, DoobieEmployeeRepository, error types etc. and replace them with vanilla Scala types like String or Throwable.
• Strip away any remaining code as long as you can still reproduce the problem. For example, the implementations of save and save2 are not needed, and neither are Ask and Raise.
• Make sure that the code compiles. This includes adding the necessary imports.

By following these guidelines, we arrive at something like this:

I think the deterministic parsers described by Swierstra and Duponcheel are a bit different from traditional parsers: they do not handle failure at all, only choice.

See also the invokeDet function in the S&D paper: