monads

问题 I am very much new to Haskell, and really impressed by the language's "architecture", but it still bothers me how monads can be pure. As you have any sequence of instructions, it makes it an impure function, especially functions with I/O wouldn't be pure from any point of view. Is it because Haskell assumes, like all pure functions, that IO function has a return value too, but in form of opcode or something? I am really confused. 回答1: One way to think of this is that a value of type IO a is a

问题 Like it says in the title: What does The last statement in a 'do' construct must be an expression mean? I ended my do block with a putStrLn like it shows in several examples I've seen, and i get an error. Code: main = do args <- getArgs file <-readFile "TWL06.txt" putStrLn results 回答1: Most of the time, it's because your code is mis-aligned and compiler assumes that your "do" block ended prematurely (or has extra code that dont really belong there) 回答2: Your last line isn't something like

问题 I'm working on using Futures for the first time in Scala and am working through an example of using the flatMap combinator; I've been following this discussion: http://docs.scala-lang.org/overviews/core/futures.html Specifically, this example: val usdQuote = future { connection.getCurrentValue(USD) } val chfQuote = future { connection.getCurrentValue(CHF) } val purchase = for { usd <- usdQuote chf <- chfQuote if isProfitable(usd, chf) } yield connection.buy(amount, chf) purchase onSuccess {

问题 I have this monad called Desync - [<AutoOpen>] module DesyncModule = /// The Desync monad. Allows the user to define in a sequential style an operation that spans /// across a bounded number of events. Span is bounded because I've yet to figure out how to /// make Desync implementation tail-recursive (see note about unbounded recursion in bind). And /// frankly, I'm not sure if there is a tail-recursive implementation of it... type [<NoComparison; NoEquality>] Desync<'e, 's, 'a> = Desync of (

问题 In Haskell Wiki's Recursion in a monad there is an example that is claimed to be tail-recursive: f 0 acc = return (reverse acc) f n acc = do v <- getLine f (n-1) (v : acc) While the imperative notation leads us to believe that it is tail-recursive, it's not so obvious at all (at least to me). If we de-sugar do we get f 0 acc = return (reverse acc) f n acc = getLine >>= \v -> f (n-1) (v : acc) and rewriting the second line leads to f n acc = (>>=) getLine (\v -> f (n-1) (v : acc)) So we see

问题 I am learning Scala right in these days. I have a slight familiarity with Haskell, although I cannot claim to know it well. Parenthetical remark for those who are not familiar with Haskell One trait that I like in Haskell is that not only functions are first-class citizens, but side effects (let me call them actions) are. An action that, when executed, will endow you with a value of type a , belongs to a specific type IO a . You can pass these actions around pretty much like any other value,

问题 In order to better understand monad transformers I implemented one. Since Javascript is dynamically typed I don't mimic type or data constructors but declare only plain old Javascript objects, which hold the corresponding static functions to form a specific monad / transformer. The underlying idea is to apply these methods to a value/values in a container type. Types and containers are separated so to speak. Array s can contain any number of elements. It is trivial to extend Array s so that

问题 I don't use Haskell a lot, but I understand the concept of Monads. I had been confused by Kleisli triple, and the category, however, fmap and join Although Haskell defines monads in terms of the return and bind functions, it is also possible to define a monad in terms of return and two other operations, join and fmap . This formulation fits more closely with the original definition of monads in category theory. The fmap operation, with type (t → u) → M t → M u , takes a function between two

问题 Not much I can do to expand the question. But here is a use case: let's say you have two monad transformers, t and s , transforming over the same monad m : master :: (MonadTrans t, Monad m) => t m a b slave :: (MonadTrans t, Monad m) => s m a b And I want to compose master and slave such that they can communicate with each other when m primitives are lifted into t and s . The signature might be: bound :: (MonadTrans t, MonadTrans s, Monad m, Monoid a) => t m a b -> s m a b -> (...) But what

问题 How can I properly prove that sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) sequenceA [] = pure [] sequenceA (x:xs) = pure (:) <*> x <*> sequenceA xs is essentially the same to monad inputs as sequenceA' :: Monad m => [m a] -> m [a] sequenceA' [] = return [] sequenceA' (x:xs) = do x' <- x xs' <- sequenceA' xs return (x':xs') In spite of the constraint Applicative and Monad of course. 回答1: Here's a proof sketch: Show that do x' <- x xs' <- sequenceA' xs return (x' : xs') is