August 2009 - Beginners

Circular Linked Lists
by Matthew J. Williams 04 Feb '10

04 Feb '10

Dear All How would one mimic, in Haskell, a C++ circular linked list i.e., where the last element precedes (points to) the first? Sincerely Matthew J. Williams

10 20

Utter Newbie - simple problems, output - GHC vs GHCi
by Nigel Rantor 02 Sep '09

02 Sep '09

I am trying to get my head around Haskell but seem to keep butting against problems that have nothing to do with FP yet, but are simply to do with not understanding the tools. I've been trying a lot of code from multiple tutorials but I keep finding that the code simply does not work out of the box, and requires some other setup I am unaware of. I am currently on Debian, using GHC 6.8.2 installed using apt, so I assume that the toolchain is installed and working correctly. For example, the most recent tutorial I've been looking at is the "yet another haskell tutorial", here - http://www.cs.utah.edu/~hal/docs/daume02yaht.pdf One of the exercises after talking about functions that act on lists is to determine the number of lowercase letters in a string. Fine, that makes complete sense to me. I figure something along the lines of: length( filter( Char.isLower "LoweR" ) ) should return the value 3 If I attempt this at the interactive GHC prompt I get the following: ------------------------------------------------------------------------------------------ wiggly@mink:~/src/ht$ ghci GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help Loading package base ... linking ... done. Prelude> show( length( filter( Char.isLower "LoweR" ) ) ) <interactive>:1:35: Couldn't match expected type `Char' against inferred type `[Char]' In the first argument of `GHC.Unicode.isLower', namely `"LoweR"' In the first argument of `filter', namely `(GHC.Unicode.isLower "LoweR")' In the first argument of `length', namely `(filter (GHC.Unicode.isLower "LoweR"))' Prelude> ------------------------------------------------------------------------------------------ If I attempt to put the code into a file and compile it I get the following: [Code] ------------------------------------------------------------------------------------------ module Main where import Char main = show( length( filter( Char.isLower "LoweR" ) ) ) ------------------------------------------------------------------------------------------ [Terminal] ------------------------------------------------------------------------------------------ wiggly@mink:~/src/ht$ ghc -o test ex3.hs ex3.hs:3:42: Couldn't match expected type `Char' against inferred type `[Char]' In the first argument of `isLower', namely `"LoweR"' In the first argument of `filter', namely `(isLower "LoweR")' In the first argument of `length', namely `(filter (isLower "LoweR"))' wiggly@mink:~/src/ht$ ------------------------------------------------------------------------------------------ This is one of the smallest examples I can think of posting for some help, and quite frankly, I'm feeling a bit dim because I just cannot understand why this doesn't work...I've tried in vain to mess with the code (I won't attempt to describe it, I'm not au fait enough with Haskell terminology yet, it would sound like gibberish *and* be incorrect) Any help would be awesome, equally, any ready-to-run examples/tutorials that people could recommend would likewise be awesome and beer-worthy[0]. Cheers, n [0] offer only applies to those in the London area or those environs where I find myself randomly

3 5

Parsec newbie question
by Patrick LeBoutillier 31 Aug '09

31 Aug '09

Hi all, I'd like to use parsec to parse IP addresses. So far I've written a (tiny) parser for bytes: byte :: GenParser Char st Word8 byte = do n <- many1 digit return (read n) The function works fine, but it accepts numbers greater than 255. How do I encapsulate this condition in the parser so that it fails (with en appropriate error message) in this case? Thanks a lot, Patrick -- ===================== Patrick LeBoutillier Rosemère, Québec, Canada

2 1

Type Class Woes ..
by Tom Poliquin 31 Aug '09

31 Aug '09

I've been writing Haskell programs (even useful ones :-) ) for awhile and I thought it was time to experiment with my own type classes. I chose the (contrived toy) problem of computing the volume of various fruits. First I wrote the code using algebraic data types .. (shown below); then I 'converted' it to use type classes (also shown below) The type class version gives me the errors .. Main.hs:12:16: Not in scope: type constructor or class `Banana' Main.hs:15:16: Not in scope: type constructor or class `Watermelon' .. which makes sense since Banana and Watermelon are 'data constructors' and not 'type constructors'. The problem is I'm not sure how to get around it .. If I try putting data Orange = Orange data Banana = Banana .. then what does 'initFruit' return .. ? it can't return [Fruit FruitType] anymore .. It seems like this should be a simple problem. I'm clearly not 'getting it'. Any help greatly appreciated, Tom ---------- Algegraic Data Type Version (works) ---------- module Main where data Fruit a = F {radius::Double, len::Double, fType::a} data FruitType = Orange | Apple | Banana | Watermelon deriving Show initFruit :: [Fruit FruitType] initFruit = [ (F 3.0 0.0 Orange), (F 3.0 0.0 Apple), (F 3.0 2.0 Banana), (F 40.0 20.0 Watermelon) ] volume :: Fruit FruitType -> Double volume F{radius=r,len=l,fType=Orange} = (4.0/3.0) * pi * r * r * r volume F{radius=r,len=l,fType=Apple} = (4.0/3.0) * pi * r * r * r volume F{radius=r,len=l,fType=Banana} = pi * (r * r) * l volume F{radius=r,len=l,fType=Watermelon} = (4.0/3.0) * pi * (2.0 * r) * l * (0.5 * l) ---------- -- Main -- ---------- main = do fruit <- return $ initFruit mapM (\f@(F{fType=t}) -> putStrLn ("Volume -> " ++ show t ++ " = " ++ show (volume f))) fruit Volume -> Orange = 113.09733552923255 Volume -> Apple = 113.09733552923255 Volume -> Banana = 56.548667764616276 Volume -> Watermelon = 67020.64327658225 ---------- Type Class Version (fails) ---------- module Main where data Fruit a = F {radius::Double, len::Double, fType::a} data FruitType = Orange | Apple | Banana | Watermelon class Volume a where volume :: (FruitType a) => Fruit a -> Double -- default spherical fruit .. volume F{radius=r,len=l} = (4.0/3.0) * pi * r * r * r instance Volume Banana where volume F{radius=r,len=l} = pi * (r * r) * l instance Volume Watermelon where volume F{radius=r,len=l} = (4.0/3.0) * pi * (2.0 * r) * l * (0.5 * l) initFruit :: [Fruit FruitType] initFruit = [ (F 3.0 0.0 Orange), (F 3.0 0.0 Apple), (F 3.0 2.0 Banana), (F 40.0 20.0 Watermelon) ] ---------- -- Main -- ---------- main = do fruit <- return $ initFruit mapM (\f@(F{fType=t}) -> putStrLn ("Volume -> " ++ show t ++ " = " ++ show (volume f))) fruit Main.hs:12:16: Not in scope: type constructor or class `Banana' Main.hs:15:16: Not in scope: type constructor or class `Watermelon'

6 8

pretty-printing data
by Michael Mossey 31 Aug '09

31 Aug '09

For debugging purposes I'm interested in pretty-printing data; to start with, lists of algebraic data types. Basically I'd like 'show' with the ability to put each entry of a list on a separate line, and indented. Note that the algebraic data might have an inner list as one of its elements, so this is a non-obvious formatting problem. I believe I can make instances of Show, can I not? Is there something called showList which I can use to code my own method of showing lists of a particular type? My understanding is that I can't make [a] an instance of Show; hence they provided showList. So basically, I'm wondering if a pretty-printing (for data!) library already exists, or whether I should try to make instances of Show. Thanks, Mike

3 2

partitions made of unique parts
by I. J. Kennedy 29 Aug '09

29 Aug '09

The following function finds all the partitions of an integer that are made of unique parts. It works, but I'm not happy with it--seems too complex. Is there a more haskelly (clever) way to implement this? -- parts n finds all the partitions of n having unique parts -- helper function parts' n r m finds partitions of n from a set r of remaining possible parts, -- with a minimum part of m. parts n = parts' n [1..n] 1 where parts' 0 _ _ = [[]] -- there's always one way ([]) to get a sum of 0 parts' n [] _ = [] -- if n /= 0, there are no possible partitions of the empty list parts' n remaining atleast = [(x:y) | x <- filter (>= atleast) remaining, y <- (parts' (n-x) (remaining \\ [x])) x] *Main> parts 11 [[1,2,3,5],[1,2,8],[1,3,7],[1,4,6],[1,10],[2,3,6],[2,4,5],[2,9],[3,8],[4,7],[5,6],[11]]

2 2

definition of combinator
by Michael Mossey 25 Aug '09

25 Aug '09

Although I can use libraries like Parsec, I don't really understand what a combinator is, theoretically. There is an article here http://en.wikipedia.org/wiki/Combinator with the statement "A combinator is a higher-order function that uses only function application and earlier defined combinators to define a result from its arguments." Okay, so I believe a "higher-order function" is a function that takes function(s) as its argument(s). I don't know what "uses only function application" means. Application of what functions to what? Can someone give a concrete example that's simple? Thanks, Mike

4 4

type inference question
by I. J. Kennedy 23 Aug '09

23 Aug '09

Given a sort function that works on numbers, you can sort in reverse order by first negating the list, then sorting, then negating again: Prelude Data.List> let revsort = (map negate) . sort . (map negate) The function sort takes any list of Ord; negate works on any Num. Prelude Data.List> :t negate negate :: (Num a) => a -> a Prelude Data.List> :t sort sort :: (Ord a) => [a] -> [a] I'd therefore expect my revsort function to work on any type that is both an Ord and a Num. However: Prelude Data.List> :t revsort revsort :: [Integer] -> [Integer] I was expecting something like revsort :: (Ord a, Num a) => [a] -> [a] instead. Question: Why did the GHCI's type inference mechanism jump to the conclusion that revsort should only work with Integer lists?

2 1

my ugly code and the Maybe monad
by Simon Parry 20 Aug '09

20 Aug '09

hello all, Intro: I'm fairly new to Haskell, read some tutorials/books, this is my first real attempt at making something rather than doing tutorial problems - I thought I'd recode some financial maths up in Haskell...see below. It seems to work ok (I haven't properly tested it yet) but I feel the pvs function is just ugly. However it seems like its a fairly common requirement for maths modelling ie using Maybe or Error or such to represent conditions on the input variables and then later having to combine those 'wrapped' values with other things. Basically it seems inelegant and I feel like I'm confusing the monadic and non-monadic parts? help/criticism welcome, thanks Simon module TimeValueMoney1 where --taken from Financial Numerical Recipes in C++ by B A Odegaard (2006): --Chapter 3 import Control.Monad --time periods - assumes now is time 0-- times :: [Int] times = [0..] minusOne :: Double minusOne = -1.0 --can have eg discrete or continuous compounding type Compounding = Double -> Int -> Maybe Double --discounting and present value-- discreteCompounding :: Compounding discreteCompounding yield elapsed | yield > minusOne = Just ( 1.0/ (1.0 + yield)^elapsed ) | otherwise = Nothing continuousCompounding :: Compounding continuousCompounding yield elapsed | yield > minusOne = Just (exp( minusOne * yield * fromIntegral elapsed ) ) | otherwise = Nothing pvs :: Compounding -> Double -> [Double] -> Maybe [Double] pvs df yield cashflow = zipWithM ( \c -> (>>= \d -> return $ c*d ) ) cashflow discounts where discounts = map discount times discount = df yield

2 3

Ambigous Types with Haskell Functional Graph Library
by Joe Schafer 19 Aug '09

19 Aug '09

Hey all, New to Haskell and I'm trying to use the FGL but I keep running into the same error. If I load Data.Graph.Inductive.Example and use one of the example functions such as ucycle I get: Ambiguous type variable `gr' in the constraint: `Graph gr' arising from a use of `ucycle' at <interactive>:1:0-7 Probable fix: add a type signature that fixes these type variable(s) Here's the type of ucycle for reference. ucycle :: Graph gr => Int -> gr () () I'm using GHC 6.10.1 and FGL 5.4.2.2 Thanks, Joe

2 1