May 2011 - Beginners - Haskell.org

Are there summary sheets of operations on lists etc. i.e. shorter than Data.List
by KC 12 May '11

12 May '11

-- -- Regards, KC

1 0

Problem with Data.Map and IO...
by Manfred Lotz 12 May '11

12 May '11

Hi there, I've got a problem creating a map. I have a list of dataset names and adding those dataset names into a map works fine like this: <----------------------------snip--------------------------------> module Main where import Data.List import qualified Data.Map as M insertRec :: M.Map String String -> String -> M.Map String String insertRec m e = let f = M.lookup e m in if f == Nothing then M.insert e "bla" m else m createMap :: [String] -> M.Map String String createMap lst = let m = M.empty in foldl' insertRec m lst main :: IO () main = do let xmlfiles = [ "a.xml","f.xml"] let ht = createMap xmlfiles print ht <----------------------------snap--------------------------------> However, actually I want to parse the xml files and adding content into the map. For this I have a function getXmlContent :: FilePath -> IO (String,String) and would like to do something like this: <----------------------------snip--------------------------------> insertRec m e = do c <- getXmlContent e let k = fst c let v = snd c M.insert k v m <----------------------------snap--------------------------------> Unfortunately, this doesn't work because of IO. I have no glue how to get this done. Any help appreciated. -- Thanks, Manfred

3 3

List Comprehensions
by Hamster 11 May '11

11 May '11

Hello, I am trying to understand list comprehensions (I am very new to Haskell) and there's one thing I simply don't understand. If I have code that looks like: combinations = [ (x,y) | x <-[1,2,3], y<-[1,2,3]] Then it happily gives me all the possible combinations of x and y. [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)] However... If I change the function to look like: combinations xs ys = [ (x,y) | x <-[xs], y<-[ys]] The output changes to: [([1,2,3],[1,2,3])] I don't understand what's going on there. Is there any way I can get it to produce all the combinations of a user supplied list? Thanks H.

3 2

Complexity of Arrays in Haskell
by Øystein Kolsrud 10 May '11

10 May '11

Hi! What's the complexity of indexing arrays in Haskell? The Data.Array documentation doesn't seem to mention complexity of any of its functions, and it's not obvious to me how to implement an array data structure with indexing being O(1). -- Mvh Øystein Kolsrud

3 3

Is there such a thing as a lazy monadic list?
by Arlen Cuss 10 May '11

10 May '11

Hi all, I'm currently trying to write a very simple VM in order to learn and stretch my Haskell. I'm currently up against a problem. I'm using an (IOUArray Int Word32) to represent the memory of a VM instance. This is all fine so far, but now I'm trying to write a 'disassemble' function that will disassemble an instruction starting from a given location in memory. Ideally I could write a function that would lazily yield successive elements from memory, sort of like this: > readVMFrom :: VM -> Address -> IO [Word32] > readVMFrom v f = do > i <- readArray (memory v) f > rest <- readVMFrom v (succ f) > return $ i : readVMFrom v (succ f) Of course, this isn't lazy, and so happily runs off the end of memory each time. (I could stop that, but that's not the point!) I'm not sure how to lazily construct a list in IO. My next thought is to instead make a function to return an action that yields successive values of memory, given some start, i.e. something like: > readVMFrom :: VM -> Address -> IO Word32 .. but I'm thinking I might have to do some StateT nonsense in order to actually keep track of which index we want to read next. (subtext: I don't know how to do that!) So I then think that perhaps I can do this by having readVMFrom return an action which yields a) the next value, b) the address of the next value (so we know how much we ate), and c) an action to yield the next value and action and so on, so on. I managed that this way (WARNING, BEGINNER HASKELL CODE FOLLOWS): > newtype RVFResult = RVFResult { getRVFResult :: (Word32, Address, IO RVFResult) } > > readVMFrom :: VM -> Address -> IO RVFResult > readVMFrom v f = do > i <- readArray (memory v) f > return $ RVFResult (i, succ f, readVMFrom v $ succ f) A function can then take an argument of type RVFResult as an indication it wants 1..n sequential values from memory: > disassemble :: RVFResult -> IO (Instruction, Address) > disassemble r = do > let (i, p, a) = getRVFResult r > case i of > 0x01 -> return (Push, p) > 0x02 -> return (Pop, p) > 0x03 -> return (Call, p) > 0x04 -> do > r <- a > let (v, p, a) = getRVFResult r > return (Out v, p) Here you can see how we consume an additional value by executing the returned action 'a'. It's damn ugly, and this almost looks like the place for a monad (possibly something involving StateT, though, I don't know!). Ideally I'd manage a lazily constructed list -- somehow I feel that's most "Haskelly" -- but does anyone else have any ideas? I kinda fleshed this last solution out as I wrote this email, so it's kinda cruddy. Cheers, Arlen

3 6

help understanding JSON
by Sean Perry 10 May '11

10 May '11

I have some JSON which looks like this: {"count":2, "result":[{"LastTrade":"31.24", "Symbol":"FOO"}, {"LastTrade":"345.12", "Symbol":"BAR"}]} (named testQuoteResult below) When I try to parse this into types defined below it failed because the Double is encoded as a String. If I change the type of LastTrade in my code to String everything is ok but I am left read'ing the String. I have defined the following using Language.JsonGrammar: import Data.Iso import Language.JsonGrammar import Prelude hiding (id, (.), head, either) import Control.Category ((.)) import qualified Data.Aeson as JS import qualified Data.ByteString.Char8 as BS import qualified Data.Attoparsec as P data MyQuote = MyQuote { price :: Double, symbol :: String } deriving(Show) myQuote = $(deriveIsos ''MyQuote) instance Json MyQuote where grammar = myQuote . object ( prop "LastTrade" . prop "Symbol" ) data MyQuoteResult = MyQuoteResult { count :: Int, result :: [MyQuote] } deriving(Show) myQuoteResult = $(deriveIsos ''MyQuoteResult) instance Json MyQuoteResult where grammar = myQuoteResult . object ( prop "count" . prop "result" ) tryJSON input = case P.parse JS.json (BS.pack input) of P.Done s v -> Right v other -> Left ("failed parse " ++ show other) Using it like this: > let Right qr = tryJSON testQuoteResult > fromJson qr :: Maybe MyQuoteResult Nothing Is there some way to convince the JSON text parser to turn "12.34" into (Double 12.34)?? An example using pure aeson would be fine if required. I just decided to play with JsonGrammar since it was announced today and it sounded interesting.

4 4

Typeclasses and generic types
by Christopher Howard 10 May '11

10 May '11

I'm learning how to use typeclasses for the first time, and I tried something like so: [CODE] data Point a = Point a a getX (Point a _) = a getY (Point _ a) = a instance Eq Point where (==) a b = getX a == getX b && getY a == getY b [/CODE] But when I try to load this in GHCI I get: [CODE] `Point' is not applied to enough type arguments The first argument of `Eq' should have kind `*', but `Point' has kind `* -> *' In the instance declaration for `Eq Point' [/CODE] This seems to be saying that Eq requires a concrete argument, which I suppose I can understand. I can fix this by changing "data Point a = Point a a" into "data Point = Point Int Int" or something like that, but that seems kind of lame: what if I want to leave my Point type more generic? (Maybe sometimes I'll need a Point Int, and other times I'll need a Point Float, or some other weird combination I haven't thought of yet.) Instead of changing the "data" declaration, can I change the "instance" declaration somehow so that it just defines an instance for a particular Point sub-type? I tried some variations like "instance Eq (Point Float)" but I haven't been able to come up with anything yet that satisfies the compiler. -- frigidcode.com theologia.indicium.us

3 3

haskell for FPGAS
by David Blubaugh 09 May '11

09 May '11

To All, Has anyone developed HASKELL FOR FPGA development ?? Thank You, Daid Blubaugh

6 6

Question about constraints, signatures
by Philippe Sismondi 09 May '11

09 May '11

I am trying to understand the Typeclassopedia article by Brent Yorgey in Monad.Reader. I am simultaneously working my way through Real World Haskell, so I may be doing things a bit out of order. Here is my question (which may itself be unclear, as I am a true *noob* at this): Why are there two different kinds of "constraints" in a signature, viz. those that specify types and those that specify typeclasses? For instance, we could write this: f :: (Num d) => d -> String -> Int In my example above there are two kinds of things that constrain f: (a) d must be an instance of Num; and (b) the second argument to f must be of type String, and f must return an Int. I (more or less) understand that types and typeclasses are not the same. But it seems to me that they do conflate in a way, if we think of types as defined by functions on them. So why should we not be able to write: f :: Num d -> String -> Int TIA. Best, - Phil -

3 4

Making a generic interpreter
by Erik Helin 07 May '11

07 May '11

Hi, I have made the following (very small and basic) interpter: data Code = PUSH Integer | ADD | BRANCH [Code] [Code] | CMP deriving (Show) data StackElement = StackInteger Integer | StackBool Bool deriving (Show) type Stack = [StackElement] eval :: [Code] -> Stack -> Stack eval [] s = s eval (PUSH n:t) s = eval t (StackInteger n:s) eval (ADD:t) (StackInteger x:StackInteger y:s) = eval t (StackInteger (x + y):s) eval (CMP:t) (StackInteger x:StackInteger y:s) = eval t (StackBool (x == y):s) eval (BRANCH c1 c2:t) (StackBool cond:s) = if cond then eval (c1 ++ t) s else eval (c2 ++ t) s Now, I would like to change StackElement to be able to work with any types, that is: data StackElement a b = StackInteger a | StackInteger b deriving (Show) How would I make this change? I thought about using typeclasses, but since type a and type b in StackElement a b clearly are related (the == operation on type a must result in type b), I need to use multi-parameter type classes (and maybe also functional dependecies?). I also thought about introducing a new type Operation: data Operation a b = Operation { cmp :: a -> a -> b, add :: a -> a -> a, (more required functions) } Is any of these solutions the preferred one, or is there another solution that I don't know of (this is very likely, I'm completely new to Haskell)? Thanks for taking your time and reading this lengthy post, Erik

4 8