- Beginners - Haskell.org

laziness and optimization
by Michael Mossey 22 Mar '09

22 Mar '09

I understand a bit about the concept of "lazy evaluation." I think of that as saying an imperative language would always make one evaluation, whereas Haskell might make 0 evaluations. I have another similar situation where an imperative language would make N evaluations of the same expression, and I would like Haskell to make only 1. This is the situation: the graphical score editor displays "LayoutItems." A LayoutItem can be a single displayed entity, like a round notehead, or it can be composed of several entities. A common situation in my code is the need to determine the size and shape of a LayoutItem. For a fundamental item, this can be looked up in a table or read from the font properties. For a composite item, some computation is required: the code must determine the positions of each sub-item and compute the bounds of a shape containing all of them. It's this latter computation, finding the bounds of a composite item, which might come up multiple times. Consider that I ask for the bounds of a composite-composite item (a composite item composed of composite items). It will run the computation associated with each composite sub-item, even though it is very likely I already make that computation when I first constructed and placed that sub-item. In an imperative language, one might cache values for later lookup. This raises the problem of keeping the cache current to the current state. So I'm wondering to what extent the haskell compiler recognizes computations it's done before. In a purely functional language this should be pretty easy, right? If it sees the same expression, it knows it will have the same value. That's my understanding, so far. Thanks, Mike

2 1

Fwd: [Haskell-beginners] Fractional Int
by Sean Bartell 21 Mar '09

21 Mar '09

Sorry, forgot to reply to all. ---------- Forwarded message ---------- From: Sean Bartell <wingedtachikoma(a)gmail.com> Date: Fri, Mar 20, 2009 at 5:58 PM Subject: Re: [Haskell-beginners] Fractional Int To: Zachary Turner <divisortheory(a)gmail.com> For a type "a" to be Fractional requires there to be: (/) :: a -> a -> a You can't divide an Int by another Int and (in general) get a third Int. You would probably want something like a "Fractionable" typeclass, with (/) :: a -> a -> b which would result in a Rational, but Haskell doesn't have this. 2009/3/20 Zachary Turner <divisortheory(a)gmail.com> > > Why is there no instance of Fractional Int or Fractional Integer? Obviously integers are fractions with denominator 1. I was just doing some basic stuff to get more familiar with Haskell, and was seriously racking my brain trying to figure out why the following wouldn't work: > > intToString :: Int -> [Char] > intToString n | n<10 = chr (n + (ord '0')):[] > intToString n = > let q = truncate (n/10) > r = n `mod` 10 > o = ord '0' > ch = chr (r + o) > in ch:(intToString q) > > (yes, this ends up converting the string in reverse, but that's another issue :P) > > I later realized that I could use members of the Integral typeclass such as divMod, mod, etc to make this better, but nonetheless, why should truncate(n/10) be invalid, when n is an Int? changing it to truncate((toRational n)/10) works, but I would expect Integers to already be rational. > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners >

3 4

Fractional Int
by Zachary Turner 21 Mar '09

21 Mar '09

Why is there no instance of Fractional Int or Fractional Integer? Obviously integers are fractions with denominator 1. I was just doing some basic stuff to get more familiar with Haskell, and was seriously racking my brain trying to figure out why the following wouldn't work: intToString :: Int -> [Char] intToString n | n<10 = chr (n + (ord '0')):[] intToString n = let q = truncate (n/10) r = n `mod` 10 o = ord '0' ch = chr (r + o) in ch:(intToString q) (yes, this ends up converting the string in reverse, but that's another issue :P) I later realized that I could use members of the Integral typeclass such as divMod, mod, etc to make this better, but nonetheless, why should truncate(n/10) be invalid, when n is an Int? changing it to truncate((toRational n)/10) works, but I would expect Integers to already be rational.

1 0

infix functions with 3 args
by 7stud 20 Mar '09

20 Mar '09

On p. 76 of RWH, it says: "If a function or constructor takes two or more arguments, we have the option of using it in infix form, where we place it between its first and second arguments." Here is my code: func2 x y = x + y func3 x y z = x + y + z Here are the results: *Main> func2 10 20 30 *Main> 10 `func2` 20 30 *Main> func3 10 20 30 60 *Main> 10 `func3` 20 30 <interactive>:1:11: No instance for (Num (t1 -> t)) arising from the literal `20' at <interactive>:1:11-15 Possible fix: add an instance declaration for (Num (t1 -> t)) In the second argument of `func3', namely `20 30' In the expression: 10 `func3` 20 30 In the definition of `it': it = 10 `func3` 20 30 How do you get a function to work using infix notation when it has 3 arguments?

3 2

Problems when trying to solve yaht exercise 3.10
by ZelluX 20 Mar '09

20 Mar '09

Hi, all I'm new to haskell and currently reading yaht. I find some problems when trying to solve exercise 3.10. The exersices asks to read a list of numbers terminated by a zero, and figure out the sum and product of the list. My program is as follows: ex3_10 = do hSetBuffering stdin LineBuffering numbers <- getNumber let sum = foldr (+) 0 numbers product = foldr (*) 1 numbers putStrLn "The sum is " ++ show(sum) putStrLn "The product is " ++ show(product) getNumber = do putStrLn "Give me a number (or 0 to stop):" num <- getLine if read num == 0 then return [] else do rest <- getNumber return (read num : rest) But when i load the program, ghci reports error: Couldn't match expected type `[a]' against inferred type `IO ()' In the first argument of `(++)', namely `putStrLn "The sum is "' In a stmt of a 'do' expression: putStrLn "The sum is " ++ show (sum) And i just don't understand the first sentence. Could you tell what does it mean? Thanks for your reply

3 3

Innovating control structures
by Girish Bhat 20 Mar '09

20 Mar '09

Ok, I keep hearing about functional programming allowing you to innovate control structures and certainly monads have a role to play there. I was wondering if you guys would point me to particularly elegant or pleasing idioms. For example, I seem to be pleased to be re-acquainted with the recursive for loop :)

1 1

Re: Advice wanted on parallel processing
by Colin Paul Adams 19 Mar '09

19 Mar '09

>>>>> "Daniel" == Daniel Fischer <daniel.is.fischer(a)web.de> writes: Daniel> If e.g. Daniel> data Move = Move {from :: Position, to :: Position} Daniel> , the instance would be Daniel> instance NFData Move where rnf (Move f t) = rnf f `seq` Daniel> rnf t `seq` () Daniel> That might require NFData instances for Position and its Daniel> components, but specifying these should be automatic. <switched to beginners list> Move is somewhat more complicated than that, but it comes down to specifying instances for data Piece_colour = Black | White and data Piece_type = Lance | Reverse_chariot | Side_mover | Vertical_mover | White_horse | Rook ... many more which I'm not sure how to do. I tried added a deriving clause, but the compiler complains: Can't make a derived instance of `NFData Piece_colour' (`NFData' is not a derivable class) In the data type declaration for `Piece_colour' here I don't have and fields to force. -- Colin Adams Preston Lancashire

2 1

Re: [Haskell-beginners] Understanding recursion in Haskell.
by The_Polymorph＠rocketmail.com 18 Mar '09

18 Mar '09

Hi Adrian, Thanks for the explanations. Could we perhaps examine one recursive example in detail, i.e., step-by-step, as I'm still confused? Maybe the following program from chapter 2 of http://book.realworldhaskell.org? myDrop n xs = if n <= 0 || null xs then xs else myDrop (n - 1) (tail xs) Danke, Caitlin --- On Wed, 3/18/09, Adrian Neumann <aneumann(a)inf.fu-berlin.de> wrote: From: Adrian Neumann <aneumann(a)inf.fu-berlin.de> Subject: Re: [Haskell-beginners] Understanding recursion in Haskell. To: beginners(a)haskell.org Date: Wednesday, March 18, 2009, 12:05 AM Am 18.03.2009 um 06:28 schrieb Caitlin: > > Hi. > > As a Haskell beginner, I was wondering if someoneone could explain how the following programs function (pardon the pun)? > This function takes some type which has an ordering defined, i.e. you can compare its elements to one another > maximum' :: (Ord a) => [a] -> a it doesn't work for an empty list > maximum' [] = error "maximum of empty list" the maximum of a one element list is the lone element. this is the base case which will be eventually reached by the recursion > maximum' [x] = x should the list have more than one element > maximum' (x:xs) compare the first element to the maximum of the other elements. if it's greater, it's the maximum > | x > maxTail = x otherwise the maximum of the other elements is the maximum of the whole list > | otherwise = maxTail how to compute the maximum of the other elements? just use this function again. after a while we will only have one element left and reach the base case above. > where maxTail = maximum' xs > > This function takes a number and a list of some type a > take' :: (Num i, Ord i) => i -> [a] -> [a] first, ignore the list and check whether n is <= 0. in this case return an empty list. this is the base case, that's eventually reached by the recursion > take' n _ > | n <= 0 = [] otherwise, check if the list is empty. this is another base case. > take' _ [] = [] if neither n<=0 or the list empty, take the first element, x, and put it on front of the prefix of length (n-1) of the other elements. use take' again, to get that prefix. after a while either n is 0 or there are no more elements in the list and we reach the base case > take' n (x:xs) = x : take' (n-1) xs > > Take two lists > > zip' :: [a] -> [b] -> [(a,b)] if either one of them is empty, stop > zip' _ [] = [] > zip' [] _ = [] otherwise prepend a tuple, build from the two first elements to the zipped list of the other elements. after a while one of the lists should become empty and the base case is reached. > zip' (x:xs) (y:ys) = (x,y):zip' xs ys > > > > quicksort :: (Ord a) => [a] -> [a] empty list -> nothing to do > quicksort [] = [] > quicksort (x:xs) = otherwise take the first element of the list and use it to split the list in two halves. one with all the elements that are smaller or equal than x, the other one with all those that are bigger. now sort them and put x in the middle. that should give us a sorted whole. how to sort them? just use quicksort again! after some splitting the lists will become empty and the recursion stops. > let smallerSorted = quicksort [a | a <- xs, a <= x] > biggerSorted = quicksort [a | a <- xs, a > x] > in smallerSorted ++ [x] ++ biggerSorted -----Inline Attachment Follows----- _______________________________________________ Beginners mailing list Beginners(a)haskell.org http://www.haskell.org/mailman/listinfo/beginners

5 5

Hudak state emulation discussion - can you give me some idea?
by Girish Bhat 18 Mar '09

18 Mar '09

Hi Everyone, I was going through the classic Hudak paper "Conception, Evolution, and Application of Functional Programming". Probably the most valuable part is towards the end where he talks about how state is represented in Haskell. On Page 48 of the PDF (page 406 of the ACM Computing survey volume), he gives the following equations "For expository purposes we would like to make the state as implicit as possible, and thus we express the result as a composition of higher-order functions. To facilitate this and to make the result look as much like the original program as possible, we define the following higher-order infix operators and functions": 1 f:=g =\s -> +fs(gs) 2 f;g =\s -> g(fs)=\s-+fs(gs) 3 f;g =\s -> g(fs) 4 goto f = f 5 f+‘g=\s-+fs+gs 6 f<‘g=\s-+fs<gs 7 if’ p c = \s + (if (p s) then (c s) else s) Unfortunately I am unable to parse/understand what he is doing here. My closure understanding too seems to be wonky. :) Would someone be kind enough to translate each of the above into plain english and explain how to read such eqns in the future? thanks!

3 5

How to display a time difference?
by Colin Paul Adams 18 Mar '09

18 Mar '09

The code of the following routine is intended to indicate how long it takes for the computer to make a move. However the time is printed (as very close to zero) long before the move is made. I must be missing something about sequencing actions in the IO monad. play_move :: IORef Game_state -> IO () play_move game_state_ior = do (_, state, _) <- readIORef game_state_ior putStr "Playing AI: " start_time <- getCurrentTime let move = recommended_move state modifyIORef game_state_ior (update_interactive_from_move move) end_time <- getCurrentTime putStrLn $ show $ (diffUTCTime end_time start_time) -- Colin Adams Preston Lancashire

4 11