Let’s just recap the definition of the Cofree datatype. data Cofree f a = a :< f (Cofree f a) That’s at least enough to diagnose the problem with the example. When you wrote 1 :< [2, 3] you made a small error that’s reported rather more subtly than is helpful. Here, f = [] … Read more
A helpful rule of thumb is when you see values in a context; monads can be seen as layering “effects” on: Maybe: partiality (uses: computations that can fail) Either: short-circuiting errors (uses: error/exception handling) [] (the list monad): nondeterminism (uses: list generation, filtering, …) State: a single mutable reference (uses: state) Reader: a shared environment … Read more
This quote explains the considerations behind having primitive streams. I’m assuming the same applied to primitive Optionals. In short, primitive streams (and probably Optionals as well) were created for performance reasons. They didn’t create them for all 8 primitive types to reduce code duplication and interface pollution. Quoting the words of Brian Goetz in the … Read more
An iterator over Result<T, E> can be collect()-ed directly into a Result<Vec<T>, E>; that is, your entire function can be replaced with: let new: Result<Vec<T>, E> = v.into_iter().collect()
It doesn’t work in scala 2.11 and earlier because Either is not a monad. Though there’s talk of right-biasing it, you can’t use it in a for-comprehension: you have to get a LeftProject or RightProjection, like below: for { foo <- Right[String,Int](1).right bar <- Left[String,Int](“nope”).right } yield (foo + bar) That returns Left(“nope”), by the … Read more
In Practice No, it can not be done, at least not in a meaningful way. Consider this Haskell code action :: Int -> IO String action n = print n >> getLine This takes n first, prints it (IO performed here), then reads a line from the user. Assume we had an hypothetical transform :: … Read more
Well, I’m not terribly satisfied with the answers given so far, but I think the comments attached to them are a bit more compelling. So I’ll summarize here: I think there’s only one sensible Functor instance that follows from Applicative: fmap f fa = pure f <*> fa Assuming that’s unique, it makes sense that … Read more
A side effect is an observable interaction with its environment (apart from computing its result value). In Haskell, we try hard to avoid functions with such side effects. This even applies to IO actions: when an IO action is evaluated, no side effects are performed, they are executed only when the actions prescribed in the … Read more
No. Consider the trivial monad: data Trivial a = Cow instance Monad Trivial where _ >>= _ = Cow return _ = Cow
Here’s a small self contained example public class Example { public static class Item { int id; } public static void main(String[] args) { getIds() .flatMapIterable(ids -> ids) // Converts your list of ids into an Observable which emits every item in the list .flatMap(Example::getItemObservable) // Calls the method which returns a new Observable<Item> .subscribe(item … Read more