monads

Context: This question is specifically in reference to Control.Lens (version 3.9.1 at the time of this writing) I've been using the lens library and it is very nice to be able to read and write to a piece (or pieces for traversals) of a structure. I then had a though about whether a lens could be used against an external database. Of course, I would then need to execute in the IO Monad . So to generalize: Question: Given a getter, (s -> m a) and an setter (b -> s -> m t) where m is a Monad, is possible to construct Lens s t a b where the Functor of the lens is now contained to also be a Monad?

I am trying to use SmallCheck to test a Haskell program, but I cannot understand how to use the library to test my own data types. Apparently, I need to use the Test.SmallCheck.Series . However, I find the documentation for it extremely confusing. I am interested in both cookbook-style solutions and an understandable explanation of the logical (monadic?) structure. Here are some questions I have (all related): If I have a data type data Person = SnowWhite | Dwarf Integer , how do I explain to smallCheck that the valid values are Dwarf 1 through Dwarf 7 (or SnowWhite )? What if I have a

I was under the impression that there was an instance for Either a somewhere, but I can't seem to find it. I have tried importing Control.Monad, Control.Monad.Instances and Data.Either as shown module Main where import Control.Monad import Data.Either import Control.Monad.Instances test :: [Either a b] -> Either a [b] test = sequence main = return () but ghc tells me that it could not deduce (Monad (Either a)). Adding instance Monad (Either a) where return = Right Right b >>= f = f b Left a >>= _ = Left a makes the code compile, but this instance declaration seems so general that it doesn't

It's nice to know (in Safe Haskell, at least) from the signature whether or not something performs IO actions, but IO encompasses a lot of different things - putStr , database access, removing and writing to files, IORefs, etc. If I'm using the type signatures as a security measure when running arbitrary code, it might be the case that I'm willing to accept some IO actions - putStr and the ilk, for instance - but not others. Is there a way to define a restricted version of the IO monad, with only a subset of the normal IO actions? If so, an example (with putStr , for instance) would be very

Apparently the only possible interpretation of runSomeMonad do ... is runSomeMonad (do ...) . Why isn't the first variant allowed by the Haskell syntax? Is there some case where foo do bar could be actually ambiguous? Jon Purdy Note that you can observe this effect with not just do , but also let , if , \ , case , the extensions mdo and proc …and the dread unary - . I cannot think of a case in which this is ambiguous except for unary - . Here’s how the grammar is defined in the Haskell 2010 Language Report, §3: Expressions . exp → infixexp :: [context =>] type | infixexp infixexp → lexp qop

Suppose I have two functions to get orders and order items: def getOrders(): Option[List[Int]] = ... def getOrderItems(orderId: Int): Option[List[Int]] = ... Note that both functions return Option[List] since each function may fail. Now I would like to get Option of List of all order items as follows: return Some[List] if both functions return Some and None if any of them returns None. I tried to compose these functions with for (see below) but it did not work. val allOrderItems = for { orderIds <- getOrders(); orderId <- orderIds; orderItems <- getOrderItems(orderId) } yield orderItems How