monads

I'm now really confused about the Error monad in which "All about monads" describes. It claims the definition of Error monad as class (Monad m) => Monaderror e m | m -> e where throwError :: e -> m a catchError :: m a -> (e -> m a) -> m a And one of the instance is Either e. instance MonadError (Either e) where throwError = Left (Left e) `catchError` handler = handler e a `catchError` _ = a Here is what I don't understand. The MonadError class take two type parameters, and (Either e) takes one, how is this instantiation work? Is this because the functional dependencies? I still don't get it.

I'm a beginner at Haskell and I've come across a situation where I would like to use the state monad. (Or at least, I think I that's what I'd like to use.) There are a million tutorials for the state monad, but all of them seem to assume that my main goal is to understand it on a deep conceptual level, and consequently they stop just before the part where they say how to actually develop software with it. So I'm looking for help with a simplified practical example. Below is a very simple version of what my current code looks like. As you can see, I'm threading state through my functions, and

I am trying to understand Monads in Haskell and during my countless experiments with code I have encountered this thing: f2 = do return "da" and the fact that it doesnt want to compile with huge error regarding type. I think the only important part is this: No instance for (Monad m0) arising from a use of return' The type variable `m0' is ambiguous So then I have changed my code to: f2 = do return "da" :: IO [Char] And it worked perfectly well. But when I have tried to mess up a bit and change the type to IO Int it was an error once again. So why the type is "ambiguous" when it actually isnt?

I've got following problem: val sth: Future[Seq[T, S]] = for { x <- whatever: Future[List[T]] y <- x: List[T] z <- f(y): Future[Option[S]] n <- z: Option[S] } yield y: T -> n: S I would want to make this code to work(I guess everyone understands the idea as I've added types). By "to work" I mean, that I would want to stay with the for-comprehension structure and fulfil expected types in the end. I know there are "ugly" ways to do it, but I want to learn how to do it pure :) As I read the internet I've reached the conclusion that my problem may be solved by the monad transformers & scalaz.

ap doesn't have a documented spec, and reads with a comment pointing out it could be <*> , but isn't for practical reasons: ap :: (Monad m) => m (a -> b) -> m a -> m b ap m1 m2 = do { x1 <- m1; x2 <- m2; return (x1 x2) } -- Since many Applicative instances define (<*>) = ap, we -- cannot define ap = (<*>) So I assume the ap in the (<*>) = ap law is shorthand for "right-hand side of ap" and the law actually expresses a relationship between >>= , return and <*> right? Otherwise the law is meaningless. The context is me thinking about Validation and how unsatisfying it is that it can't seem to

My code contains quite a few double option types; I've been using the Option.map function quite successfully so far to eliminate the need to have to match on Some and None all over the place and treat them as lifted types but am not sure what to do in the following scenario: let multiplyTwoOptions option1 option2 : double option = if not (option1.IsSome && option2.IsSome) then None else Some (option1.Value * option2.Value) I've read that you shouldn't use IsSome in this way, but the alternative (as far as I can see, to pattern match on both sequentially, seems quite long winded). I'm still