4

I am a complete beginner to Haskell, although familiar to the functional paradigm in languages like Python, F#, Java, C# and C++(in a limited way).

Something that just keeps escaping me is IO in haskell. I tried several times, even learned C# and F# in between my tries of getting around it.

To be more specific I am referring to getting IO without do notation, using do notation, IO becomes trivial. It might be bad practice, but in my spare time I like to see if I can get things done in one continuous expression. As much of a bad practice as that is, it is fun.

Such an expression is usually of the sort(in pseudo-haskell):

main = getStdinContentsAsString 
           >>= ParseStringToDataStructureNeeded
           >>= DoSomeComputations 
           >>= ConvertToString 
           >>= putStrLn

I have no problem with the last four parts. One of the reasons I learned F# was just to see if there was something i was not getting my head around aside from IO, but as soon as I had the convenient Console.ReadLine() of F# which returns a plain old String it was basically smooth sailing.

Which brings me back to another go at haskell, again stopped by the IO mechanism.

I have managed(using another question here) to get reading a int from the console, and print "Hello World!" that many times

main = (readLn :: IO Int) >>= \n -> mapM_ putStrLn $ replicate n "Hello World!"

I would like to get at least some "general use" way to just read the whole contents of the stdin(possibly multiple lines, so getContents would need to be the function of choice) as a string, and then i can process the string using other functions like unlines and then map.

Some of the things that I already tried:

As I said, getContents would be what I need(unless there is some equivalent to it).

Using logic, since

getContents :: IO String

Then I would need something that takes an IO String and returns a lain old String. Which is(as far as i know)

unsafePerformIO :: IO a -> a

However for some reason ghc is not happy:

* Couldn't match type `[Char]' with `IO (IO b)'
  Expected type: String -> IO b
    Actual type: IO (IO b) -> IO b
* In the second argument of `(>>=)', namely `unsafePerformIO'
  In the expression: getContents >>= unsafePerformIO

Another thing I tried: this works without a problem;

main = getContents >>= putStrLn

Even though the type returned by getContents is an IO action and not the per se String that putStrLn wants

getContents :: IO String
putStrLn    :: String -> IO ()

Somehow the action is magically executed and the resulting string is passed into the put function.

But then when I try to add something in, like simply appending " hello" to the input before printing it:

main = getContents >>= (++ " hello") >>= putStrLn

I suddenly get a type mismatch:

Couldn't match type `[]' with `IO'
  Expected type: String -> IO Char
    Actual type: [Char] -> [Char]
* In the second argument of `(>>=)', namely `(++ " hello")'
  In the first argument of `(>>=)', namely
    `getContents >>= (++ " hello")'
  In the expression: getContents >>= (++ " hello") >>= putStrLn

Somehow the IO action isn't executed anymore(or maybe I just don't understand this).

I have also tried numerous things, with combinations of getLine, readLn, getContents, unsafePerformIO, read, fmap to no avail.

This is just a very basic example but it illustrates perfectly the problem that made me give up haskell several times now(and probably I'm not the only one), although the stubbornness of wanting to get my head around it, and learn what is pretty much THE functional programming language keeps me coming back.

To conclude:

  1. Is there something I'm not getting?(99% yes)

  2. If yes, then what?

  3. How should I go about reading the whole stdin and processing it all in one continuous expression?(If I need only 1 line, I guess whatever the solution is, it would also work with getLine sine it is basically the sister of getContents)

Thanks in advance!

Improve this question
5
  • 2
    Yes. You mix up values wrapped in an IO monad and simple values. If you do m >>= f, the content wrapped in IO is passed to f. f has signature f :: a -> IO b, so it produces another (well possibly the same) value wrapped in an IO monad. So getContents >>= (++ " hello") makes no sense, since (++ "hello") does not return an IO b. You can however use getContents >>= putStrLn . (++ " hello") Commented Nov 4, 2017 at 20:28
  • @WillemVanOnsem I'm sorry, but it is still unclear for me. If only the contents wrapped in IO is passed as an argument, then in getContents >>= (++ " hello"), a String(or [Char]) should be what is passed on into (++ " hello"), right? And (++ " hello") has type :: [Char] -> [Char] so if a String is passed into (++ " hello"), what is the problem? Commented Nov 4, 2017 at 20:37
  • 1
    I think your conclusion about do notation is wrong, it's just a syntax extension. If you don't understand how to write program without do notation then you don't understand it. Commented Nov 4, 2017 at 20:45
  • You seem to be looking for the interact function. main = interact (++ " hello") Commented Nov 4, 2017 at 20:54
  • 1
    One thing that may help you in the future is to write your function in do notation and then desugar it manually, or think about what the expression you wrote manually using >>= would look like in do notation. For example, your erroneous expression getContents >>= (++ " hello") >>= putStrLn corresponds to the do notation do { x <- getContents; y <- x ++ " hello"; putStrLn y }, making it clear where the error is: you have y <-, so the right-hand side must be an IO action, but instead it’s just a String. One solution is to wrap it in pure (or return) to make it an action. Commented Nov 5, 2017 at 11:04

3 Answers 3

Reset to default
11

The main thing you're not considering seems to be the type of >>=:

(>>=) :: IO a -> (a -> IO b) -> IO b

In other words, you don't need to "unwrap" IO String to String; the >>= operator already hands a plain String to its right operand (the function):

getContents >>= (\s -> ...)
--                ^ s :: String

The reason getContents >>= (++ " hello") fails is that >>= requires the function to return an IO ... value, but (++ "hello") :: String -> String.

You can fix this by adding return :: a -> IO a into the mix:

getContents >>= (return . (++ "hello"))

This whole expression has the type IO String. It will, when executed, read data from stdin, append "hello" to it, and return the resulting string.

Thus,

getContents >>= (return . (++ "hello")) >>= putStrLn

should work fine. But it's more complicated than necessary. Conceptually speaking, return wraps a value in IO and >>= unwraps it again (sort of).

We can fuse the return / >>= bits on the right:

getContents >>= (\s -> putStrLn (s ++ "hello"))

I.e. instead of taking getContents :: IO String, adding "hello" to it to form a new IO String action, then attaching putStrLn :: String -> IO () to it, we wrap putStrLn to create a new String -> IO () function (that appends "hello" to its argument before handing the thing off to putStrLn).

Now if we want to, we can get rid of s by standard points-free tricks:

getContents >>= (putStrLn . (++ "hello"))

A note about IO in general: The thing to keep in mind is that IO ... is a normal Haskell type. There is no magic happening here. >>= doesn't execute any actions; it just combines a value of type IO something and a function to construct a new value of type IO somethingelse.

You can think of Haskell as a pure meta-language that constructs an imperative program (i.e. a list of instructions to execute) as a data structure in memory. The only thing that's actually executed is the value bound to Main.main. That is, it's like an imperative runtime runs your Haskell code to produce a pure value in main :: IO (). The contents of this value are then executed as imperative instructions:

main :: IO ()
main =
    putChar 'H' >>
    putChar 'i' >>
    putChar '\n'

main is bound to a data structure representing the imperative program print 'H'; print 'i'; print newline. Running the Haskell program builds this data structure, then the runtime executes it.

This model is not complete, though: The imperative runtime can call back into Haskell code. >>= can be used to "embed" Haskell functions in the imperative code, which can then (at runtime) inspect values, decide what to do next, etc. But all of that happens in the form of pure Haskell code; only the IO value returned from f in x >>= f matters (f itself has no side effects).

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

kudos for using the much needed (to a newbie) parens, even if extraneous and uncool. :)
"f itself has no side effects" ... as it constructs an IO action description purely, which will then be run by the imperative runtime and may well have some side effects at that time, as constructed.
4

  1. Is there something I'm not getting?(99% yes)

    Yes.

  2. If yes, then what?

    An IO String is something conceptually utterly different from a String. The former is like a cooking recipe, the latter like a meal.
    Until you feel like an expert Haskeller, you'd better forget that there's such a thing as unsafePerformIO. That is something you should never need in normal Haskell code, only for FFI bindings to impure C code or for last-resort optimisations.

  3. How should I go about reading the whole stdin and processing it all in one continuous expression?

    main = getContents >>= putStrLn . (++ " hello")

    Note that there are only two IO actions here: getContents and putStrLn. So you only need one bind operator to get information from one action to the other.
    In between, you have the pure (++ " hello"). That does not need any monadic bind, just function composition, to channel through information.
    If you find the mixed direction of information-flow ugly, you can also use the flipped bind:

    main = putStrLn . (++ " hello") =<< getContents

    Alternatively, you could use a monadic bind, but you'd first need to masquerade the pure function as an IO action (an action which doesn't make use of any of the side-effect possibilities):

    main = getContents >>= pure . (++ " hello") >>= putStrLn

    Or you could, rather than “transforming putStrLn to prepend " hello" after the stuff it prints”, instead “transform getContents to prepend " hello" to the stuff it fetches”:

    main = (++ " hello")<$>getContents >>= putStrLn

    All of these are equivalent by the monad laws.

Improve this answer

2 Comments

Thank you!! This was so clear. One more question if I may. What does the pure function do? The documentation just says it "lifts a value", what is that supposed to mean?
pure is almost the same as return, it's only slightly more general and arguably better named. (return is in a few situations analogous to the return keyword of procedural languages, but with very significant differences.) Both just “wrap up” a pure value so it has the type of a monadic action which does not actually have any side-effects. “Masquerade” is actually quite a fitting word I'd say.
3
  1. Is there something I'm not getting?(99% yes)

Yes. The function on the right side of the >>= is a function that has signature a -> m b with m the monad.

A metaphor: birthday presents

Something that helped me to understand monads (and functions with bind functions >>=) is not to think about IO.

You can also see a monad (note that IO is just one of the many monads) as a collection. For instance a Maybe a, this is also a monad.

You can see Maybe a as some sort of "box". That box can have an object (in case of Just x), or can be an "empty box" (instead of a Nothing).

Now the bind operator >>= has such a box on the left side, and a function f :: a -> Maybe b on the other side. Imagine that f is a person, and currently it is their birthday. He/she receives the content of the box, and has to pass another present to the next person on the calendar. So the bind operator >>= will open the box, pass that to the person, and expects a new present it can then further be processed.

So to make a story short: you have to return a new box. Now (++ " hello") takes as input the string, but it does not puts that content into a new box (so there is no party :( ).

You can however wrap it into a box yourself. In order to do that, there is the return function (this is a function, not a keyword). So you can write it as:

getContents >>= return . (++ " hello") >>= putStrLn

Note that the functions do not have to give the same "present", but the type of "box" (the monad) has to be the same. For instance putStrLn has type String -> IO (). So putStrLn is a person that you can make happy with a string as present, and the function will return a box with a () instance in it (or an empty box, there is by the way only one value for (): ()).

We can thus do the string processing simply by one function, like:

getContents >>= putStrLn . (++ " hello")

So if you write a piece of code like:

a >>= b >>= c >>= d >>= e

It means that a will construct the first box. The bind operator will open the box and handle the content to b. Based on the content b will construct a new box (with a type of object in it he/she knows c likes). The bind operator opens the box and passes the content to c, and so on.

What has this got to do with I/O

I/O functions can be seen as the people in the story of the birtday presents. They return an "IO box" so to speak with content in it. The bind operator will open the "IO box" (in fact >>= is one of the few functions that knows how to open the IO box), and pass the content to the next function. By doing it that way, it will enforce order, since the next person can not process the present if the previous person has not first inspected their present and constructed a new one.

Maybe revisited

I/O is rather hard I/O monad to understand, since it is wired into the computer system. An easier monad to understand is the Maybe monad. As we already discussed, Maybe has the following constructor:

data Maybe a = Nothing | Just a

Now we imagine Nothing as:

  +---+
 /   /|
+---+ +
|   |/
+---+

and Just x as:

  +---+
 /   /|
+---+ +
| x |/
+---+

a box with content. Now of course you probably know how to unwrap the Just x constructor and obtain the x value. But imagine that we are not allowed to do that. Only the >>= operator is allowed to open the Maybe box.

Then we can construct a monad with:

instance Monad Maybe where
    return x = Just x

    (>>=) Nothing _ = Nothing
    (>>=) (Just x) f = f x

What we see is a return function, that wraps an object into a Maybe "box", so with return, we can make a "present".

The bind operator will inspect the present on the left side. In case it turns out that nothing is in the box, it will not bother the person on the right side, and simply return Nothing.

In case the box contains an x, it will give that object to f, but expects f to construct a new present. >>= thus opens the present. He/she is a "professional birthday present opener".

So now we can write somthing like:

Just 2 >>= Just . (+5) >>= Just . (*6)

It will return Just 42. Why? We start with a present that contains a 2. >>= unwraps the present, and handles the content to Just . (+2), so we evaluate (Just . (+2)) 2. Note that the Just of Just 2 has disappeared. SO now we evaluate this, and the second item in the chain thus handles a Just 7 to the system.

This package is again opened, and guess what, it contains a 7, now that 7 is handled to the last function Just . (*6) so the last function will multiply its present by 6 and wrap it again into a box.

If you however write:

Just 2 >>= (+5) >>= Just . (*6)

this will fail. Why? Because apparently the second function is not in a good mood, and forgot to wrap his/her gift into a box.

Improve this answer

1 Comment

Thank you! The box analogy actually worked. Although it is so weird that no tutorial or documentation(at least that i found) mentioned that you need to re-wrap the value before the next bind, some even hinted that one you unwrapped it, it's smooth sailing.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.