monadic | helps dealing with exceptional situations | Functional Programming library

The Stdio library, which is a part of the Janestreet industrial-strength standard library, already provides such functions, which are, of course safe, e.g., In_channel.read_all reads the contents of the file to a string and corresponding Out_channel.write_all writes it to a file, so we can implement a cp utility as,

Yes, since OCaml 4.08, it is possible to describe let operators. For example:

Monads are usually represented by only two operators :

In Haskell there are some standard (i.e. in the base lib) operators for that.

First, your andThen function is the well known Kleisli composition:

If I found the correct documentation page, blobContents looks like a non-monadic function, so you can't use bc <- blobContents blob. Use instead let bc = blobContents blob.

This is consistent with the error message, which states that the actual type is not wrapped under IO.

_{(this is a completely new version of this answer).}

You have

As written by @LuisMiguelMejíaSuárez

As the error clearly says, IO does not have a withFilter method. (You can check the scaladoc here). When you put the type explicitly, you are basically filtering all elements that match such type. And, since the method does not exists, it won't compile. - And no, I do not know any workaround.

But, I can think on at least ne reason of why it should not have it. IO is not exactly a "container" of elements, like List, since it only is a description of a computation, and if you ant to see it like a container it will only had one element, like Option. But, unlike the former, there is not concept of empty IO. Thus, filtering an IO would not make sense.

The workaround that I have found is moving the filter inside another function :

It's not possible at the moment to implement monad comprehension for List, Flow, and other non-deterministic data structures that emit more than one value. The current implementation of continuations in Kotlin is single shot only. This means a continuation can resume a program with a single emitted value. Resuming the program more than once requires hijacking the continuation stack labels with reflection in order to replay their state in the second resumption. Additionally replaying a block in which a multishot data type is binding would replay all effects previous to the bind since the block has to emit again.