April 2014 - Beginners

Problem combining monads <sigh!>
by John M. Dlugosz 09 Apr '14

09 Apr '14

I think I was looking at the page <http://learnyouahaskell.com/for-a-few-monads-more#state> a few paragraphs under the H3 “The join function”. It mentions “…we wanted to combine several of them into one, be it with <*> or >>=,…” Now I'm actually quite comfortable with Applicative syntax, and am preferring it in places where older texts and examples use monads or fmap etc. (I look forward to an updated standard where Monads are derived from Applicatives.) (Aside: is there a "history" function in GHCi to show the last few commands I typed?) So, I tried a GHCi example starting with: λ>(+7) <$> [1,2,3] λ>[(+7), (*2)] <*> [1,2,3] no sweat. Now use >>= to do the same thing: λ>[(+7), (*2)] >>= [1,2,3] -- nope (I'll spare the error messages, which inspired some of the other things to try, some of which were just to explore the errors themselves) λ>[(+7), (*2)] <<= [1,2,3] -- nope λ>[(+7), (*2)] =<< [1,2,3] -- nope λ>[return (+7), return(*2)] =<< [1,2,3] -- nope (Use a single function as a simpler starting point) λ>(+7) =<< [1,2,3] -- nope λ>return (+7) =<< [1,2,3] -- nope λ>return (+7) >>= [1,2,3] -- nope λ>return [1,2,3] [1,2,3] it :: [Integer] -- just checking λ>[1,2,3] >>= (+7) -- nope λ>[1,2,3] >>= do (+7) -- nope. Error messages are talking about No instance for (Num [b0]) arising from the literal `1' so why is it looking inside the monad at one of the values and thinking that itself should be a list? λ>[1,2,3] >>= [(+7)] -- nope λ>[1,2,3] >>= (+7).return -- nope, but got *two* errors out of that one λ>[1,2,3] >>= liftM(+7) -- nope λ>[1,2,3] >>= liftM(+7) ::[Integer] -- nope λ>[1,2,3] >>= liftM(+7) ::Integer -- nope λ>[1,2,3] >>= liftM((+7) :: Integer -> Integer) -- nope λ>[[1,2,3]] >>= liftM((+7) :: Integer -> Integer) [8,9,10] it :: [Integer] Ah, I'm getting somewhere. But back to the question of why is the element of the list (nondeterminism monad) want its own element to be a list too? λ>return [1,2,3] >>= liftM((+7) :: Integer -> Integer) [8,9,10] it :: [Integer] Same thing. But the list is already a monad, not a bare (scalar) value, so what's going on? λ>[1,2,3] >>= (+7) -- nope λ>[1,2,3] >>= map(+7) -- nope λ>[1,2,3] >>= liftM(+7) -- nope Am I starting to repeat myself? λ>[1,2,3] >>= liftM(+7) ::[Integer] -- nope Give up for the evening. I wonder if that is a record for how many ways it can be incorrect? I'm frustrated, especially since the Applicative syntax worked so easily. But the referenced page and other texts casually say how they are interchangable. Urrrgh! Please enlighten? —John

6 7

How to read: Pearls of Functional Algorithm Design
by Kim-Ee Yeoh 08 Apr '14

08 Apr '14

Bruce earlier emailed about trying to read this book but struggled with not having basics like fold laws and list induction. It turns out there's still a lot to gain from the book even if the mathematical content is out of grasp for now. I've written up some tips on how to get started: http://www.atamo.com/blog/how-to-read-pearls-by-richard-bird-1/ The preamble is a bit long but it helps to keep the big picture firmly in mind. -- Kim-Ee

1 0

monad transformers and laziness
by Dennis Raddle 08 Apr '14

08 Apr '14

I wrote some code as part of my effort to do backtracking search of musical structures. Most recently I wrote a function that "pruned" the search tree by looking for illegal combinations of notes. In the interest of efficiency I wanted this algorithm to terminate as soon as it encountered an illegal combination rather than hunt the entire structure for every illegality. This made me think of the laziness of "or": a function like g = x || y || z will not evaluate y and z if x turns out to be true. I was also writing this code within a stack of monad transformers: State, ErrorT, and WriterT. This was primarily for debugging reasons: I wanted to have ErrorT to give good error messages with context, WriterT to log events for later perusal, and State was there for convenience. I called this monad stack "Er." So the first thing I wrote was something like this: -- return True if an illegal combination is found prune :: Music -> Er Bool prune music = do flags <- forM [0..size music-1] (\ix -> checkOneNote music ix) return $ or flags checkOneNote :: Music -> Int -> Er Bool checkOneNote music ix = do tell $ "Checking note " ++ show ix ++ "\n" -- note: were thunks created by following line left unevaluated thanks to laziness of "or flags" above? doSomething music ix I already knew from past experience that mapM (and forM) evaluate every computation within the list so I wasn't really expecting this to be lazy, and it wasn't. Judging from what was "told" to my MonadWriter, I could see it was checking every note and not stopping early at the first illegal note. My first question is: by any chance was this an illusion through my use of "tell"? What I mean, is that was it leaving thunks unevaluated thanks to the "or flags" expressions lazy behavior, or would it have left them unevaluated if I hadn't had the "tell" there? I rewrote this using this function: pruneRecursive :: Music -> Int -> Int -> Er Bool pruneRecursive music maxIx ix | ix == maxIx = return False | do flag <- checkOneNote music maxIx ix if flag then return True else checkOneNote music maxIx (ix+1) According to the writer messages, this was not doing any unnecessary work. Just wondering if it was really necessary to rewrite this. What if I removed the tell messages later, or put them inside 'when' like this when (debugFlag) (tell ..) and then set debugFlag to False for time-critical program runs? Dennis

1 0

What is a "Monad Comprehension" ?
by John M. Dlugosz 08 Apr '14

08 Apr '14

I know about List Comprehensions, but what is a general Monad Comprehension? List Comprehensions are the use of set-builder notation to define a list, so I don't understand how that would generalize.

4 4

State as function?
by martin 07 Apr '14

07 Apr '14

Hello all, in my program, I have to keep track of the State of a Guitar, i.e. where the fingers are on the fretboard and which strings are currently playing. Thus I need to associate some information to each of the 6 strings. I started out with assoc lists and hashmaps. However, I found it diffiult to ensure that all 6 GuitarString have a something attached and found myself messing with Maybes. In the real world, there is no way a GuitarString can have "no state at all", while the HashMap approach would provide this option. Then I thought, hey I really just need a function from GuitarString to something, so why not make that function the state? That was certainly doable, but I still have my doubts whether this is the correct way of doing such things. What is particularly worrying is that a state change will most likely affect a single GuitarString only. So I need to create a new function which answers the new something for that particular GuitarString and calls the old function for strings whose state hasn't changed. So with many state changes, I will get a deep call hierarchy. Though in the real world this is unlikely to cause problems, it makes me worry. What do you think?

4 8

What does "(# #)" mean?
by John M. Dlugosz 06 Apr '14

06 Apr '14

The sources I've learned about thus far are not helping me with this one. What's "(# #)"? Haskell is search-hostile.

5 8

iterated function value sequence
by John M. Dlugosz 06 Apr '14

06 Apr '14

What's a good way to produce an iterated function value sequence? That is, f(x), f(f(x)), f(f(f(x))), etc. ref: https://www.youtube.com/watch?v=09JslnY7W_k

2 5

Trying to grasp Monads - IO and delayed actions
by John M. Dlugosz 06 Apr '14

06 Apr '14

A spiral approach to learning: you understand, then you learn more, and then you are more confused than ever. I recall that a function in the IO Monad just combines actions to make a big action list, and doesn't actually do the side-effect-laden "work" until it is later triggered, normally because the program is defined to evaluate main. Depending on the time of day and which example I pick, I can sometimes follow what's "really happening" in the definition of >>=. But here are some specific questions: In <http://www.haskell.org/haskellwiki/Monads_as_computation> > What is a for-each loop really? It's something which performs some action based on each > element of a list. So we might imagine a function with the type: > > forM :: (Monad m) => [a] -> (a -> m b) -> m [b] > > (as an added bonus, we'll have it collect the results of each iteration). > > We can write this with sequence and map: > > forM xs f = sequence (map f xs) > > we apply the function to each element of the list to construct the action for that > iteration, and then sequence the actions together into a single computation. > So map by itself produces a [m b]. Why does it need to be turned into m [b]? What does the 'sequence' accomplish, other than restructuring the results that already exist? The reason I asked about (#⋯#) is because I wanted to see what IO was really doing, to see what the difference was between using >>= initially and then somehow "cranking" it later. <http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC-Base.html#%3E%…> lists > instance Monad IO where > {-# INLINE return #-} > {-# INLINE (>>) #-} > {-# INLINE (>>=) #-} > m >> k = m >>= \ _ -> k > return = returnIO > (>>=) = bindIO > fail s = failIO s > > returnIO :: a -> IO a > returnIO x = IO $ \ s -> (# s, x #) > > bindIO :: IO a -> (a -> IO b) -> IO b > bindIO (IO m) k = IO $ \ s -> case m s of (# new_s, a #) -> unIO (k a) new_s > > thenIO :: IO a -> IO b -> IO b > thenIO (IO m) k = IO $ \ s -> case m s of (# new_s, _ #) -> unIO k new_s > > unIO :: IO a -> (State# RealWorld -> (# State# RealWorld, a #)) > unIO (IO a) = a where bindIO is the function of interest. In a chain of commands, getLine might be the 'k' argument to bindIO. Somewhere there's a real machine function called to do the reading from the file, right?

3 3

How can I fix this 'where' error ?
by S. H. Aegis 05 Apr '14

05 Apr '14

Hi. I'm new to Haskell. I try to solve Euler Project for studying Haskell through Googling, reading books. There is a error in where sentence, but I can't fix this. maxEleList :: String -> String -> [Int] maxEleList xs ys = maxOfTwo upperList lowerList where upperList = map turpleSum $ zip (toIntList xs) (toIntList ys) lowerList = map turpleSum $ zip (toIntList xs) (tail $ toIntList ys) Error message is ~/maxPathSum.hs: line 4, column 75: Parse error Error message: Parse error: = Code: maxEleList xs ys = maxOfTwo upperList lowerList where upperList = map turpleSum $ zip (toIntList xs) (toIntList ys) > lowerList = map turpleSum $ zip (toIntList xs) (tail $ toIntList ys) How can I fix this? Thank you for your kind help. S. Chang ---------------- This code is for Euler project: problem 18, and whole code is like this... (Not yet finished...) maxEleList :: String -> String -> [Int] maxEleList xs ys = maxOfTwo upperList lowerList where upperList = map turpleSum $ zip (toIntList xs) (toIntList ys) lowerList = map turpleSum $ zip (toIntList xs) (tail $ toIntList ys) maxOfTwo :: [Int] -> [Int] -> [Int] maxOfTwo [] [] = [] maxOfTwo (x:xs) (y:ys) = max x y : maxOfTwo xs ys turpleSum :: (Int, Int) -> Int turpleSum (x, y) = x + y toIntList :: String -> [Int] toIntList = map (\x -> read x :: Int) . words rowData :: [[Int]] --rowData = reverse $ map (map (\x -> read x :: Int) . words) [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15] rowData = map (map (\x -> read x :: Int) . words) [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15] r1 = "75" r2 = "95 64" r3 = "17 47 82" r4 = "18 35 87 10" r5 = "20 04 82 47 65" r6 = "19 01 23 75 03 34" r7 = "88 02 77 73 07 63 67" r8 = "99 65 04 28 06 16 70 92" r9 = "41 41 26 56 83 40 80 70 33" r10 = "41 48 72 33 47 32 37 16 94 29" r11 = "53 71 44 65 25 43 91 52 97 51 14" r12 = "70 11 33 28 77 73 17 78 39 68 17 57" r13 = "91 71 52 38 17 14 91 43 58 50 27 29 48" r14 = "63 66 04 68 89 53 67 30 73 16 69 87 40 31" r15 = "04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"

2 2

Definition of last: why complicate it?
by Dimitri DeFigueiredo 05 Apr '14

05 Apr '14

I was looking at the definition of last in the prelude and saw this code (from http://hackage.haskell.org/package/base-4.2.0.1/docs/src/GHC-List.html) -- | Extract the last element of a list, which must be finite and non-empty. last :: [a] -> a #ifdef USE_REPORT_PRELUDE last [x] = x last (_:xs) = last xs last [] = errorEmptyList "last" #else -- eliminate repeated cases last [] = errorEmptyList "last" last (x:xs) = last' x xs where last' y [] = y last' _ (y:ys) = last' y ys #endif Question: What does the second "eliminate repeated cases" definition of last gain compared to the first (simpler) one? Thanks Dimitri

5 10