- Beginners - Haskell.org

Convert my own types to the Haskell types using typeclass
by ke dou 11 Apr '14

11 Apr '14

Hi, I want to define a typeclass that can convert my own types like MyBool, MyInt, MyOption to according Haskell types -- Bool, Int, Maybe. Currently I can convert the first two types, but for MyOption, I don't how to do, since it is a polymophic type. Here is my toy program: -------------------------------------------------------------- {-# LANGUAGE TypeFamilies #-} module Coercible where import qualified Prelude data MyBool = MyTrue | MyFalse data MyInt = Zero | One | Two data MyOption a = Some a | None class Coercible a where type Return a :: * toHaskell :: a -> (Return a) instance Coercible MyBool where type Return MyBool = Prelude.Bool toHaskell MyTrue = Prelude.True toHaskell MyFalse = Prelude.False instance Coercible MyInt where type Return MyInt = Prelude.Int toHaskell Zero = 0 toHaskell One = 1 toHaskell Two = 2 instance Coercible (MyOption a) where type Return (MyOption a) = Prelude.Maybe a toHaskell (Some a) = Prelude.Just a toHaskell None = Prelude.Nothing -------------------------------------------------------------------------- The problem occurs when I am trying to use "toHaskell (Some MyBool)", the error message is "Not in scope: data constructor `MyBool'". Any hints will be appreciated !! Best, --Ke

4 5

Windows x64 ?
by John M. Dlugosz 11 Apr '14

11 Apr '14

The Haskell Platform has a single download link for "Windows" which seems to be 32-bit only. But GHC is available for Win x64. Their site dissuades downloading their installation and recommends getting Haskell Platform instead. So, is there an easy way to get 64-bit versions of compiler or compiled executables so produced?

1 0

Guards problem
by Stijn Muylle 10 Apr '14

10 Apr '14

All, I ran into a small problem using guards, and I don't really understand what I'm doing wrong. I have this code: ---------------------------------- import Data.List.Split type Cell = Bool data Board = Board [[Cell]] deriving Show trueList = True : trueList createBoard :: Int -> Int -> Board createBoard x y = Board (chunksOf x (take (x * y) trueList)) getCellAt :: Int -> Int -> Board -> Cell getCellAt x y (Board b) | x >= (length b) = False | y >= (length (b !! 0)) = False | otherwise = (b !! x) !! y ----------------------------------- When I try to execute this: getCellAt (-1) 0 $ createBoard 3 3 I get a negative index exception. However, as -1 is smaller than 3 (length of the board), I would expect False to be returned. Am I overlooking something? Thanks! Stijn

3 4

Nonsensical behavior with http-conduit, httpLbs
by Christopher Allen 10 Apr '14

10 Apr '14

Repro'd on GHC 7.8.1 and 7.6.3 Original code is: https://github.com/bitemyapp/bloodhound/ The code only works if I manually (out of band) run insertData (in a REPL) and then run main with the insertData invocation stripped out. If I run main with the insertData invocation included, it throws an exception (head) because the search results are empty. The behavior is as if queryTweet was executing after insertData deleted the index, but before it inserted the new data. The following is a stripped down example: insertData :: IO () insertData = do let encoded = encode exampleTweet _ <- deleteExampleIndex created <- createExampleIndex docCreated <- indexDocument (Server "http://localhost:9200") "twitter" "tweet" exampleTweet "1" print "test" return () el queryTweet :: IO (Either String Tweet) queryTweet = do let queryFilter = BoolFilter (MustMatch (Term "user" "bitemyapp") False) <||> IdentityFilter let search = Search Nothing (Just queryFilter) reply <- searchByIndex testServer "twitter" search let result = eitherDecode (responseBody reply) :: Either String (SearchResult Tweet) let myTweet = fmap (hitSource . head . hits . searchHits) result return myTweet main :: IO () main = do _ <- insertData myTweet <- queryTweet print myTweet further up the call chain, the http call is getting dispatched with http-conduit's gear, the result returned with the expression: withManager $ httpLbs req Included this in case it affects the semantics. Can anybody help? This has stumped me for a couple hours and I couldn't get anything clueful on IRC. Thanks to any that help. --- Chris

2 6

Re: [Haskell-beginners] function not working as expected, type issues (David McBride)
by Alexej Magura 10 Apr '14

10 Apr '14

Thanks displayD :: String -> Int -> IO () displayD string 0 = return () …. is exactly what I was looking for. -- Alexej Magura Sent with Airmail

1 0

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