- Beginners - Haskell.org

appropriateness of haskell for GUIs
by Michael P Mossey 23 Mar '09

23 Mar '09

Hello, I'm totally new to Haskell. I'm thinking of using it for a personal project, which is a gui-based musical score editor. (*) Why Haskell? I've always been interested in proving my software's correctness, usually in practical and informal sense. In other words, I would like to reduce bugs by having a really good understanding of what my software does. I also just want to learn Haskell. Before I invest a lot of time in learning Haskell, however, I want to understand if it's the right language for doing a gui-based musical score editor. First of all, I need a gui toolkit of some sort, and I notice that bindings to Qt exist. I'm already very familiar with Qt, so that's good. I also need to access the Windows midi api, and I see there is a module called hmidi. However, a gui program is essentially event driven and heavily interacts with the outside world. I don't know how compatible these ideas are with Haskell. If I don't use Haskell, I will probably use Python, which I already know well. So basically the question is: Haskell or Python? Note: I would enjoy learning Haskell, so this is not a question of which language is better in an absolute sense... if Haskell is suitable, but not the best choice, I will still probably use it. Thanks, Mike (*) For those who ask why I'm doing my own music score editor when many already exist, it's because it needs to be integrated with my own computer-assisted composition system. As an editor, it will be primitive: that's not its main purpose.

5 4

splitWith and foldr stack overflow
by Sean Bartell 22 Mar '09

22 Mar '09

I wrote a splitWith function (from RWH) and then converted it to use foldr: splitWith, splitWith2 :: (a -> Bool) -> [a] -> [[a]] splitWith p xs = let (ls, ts) = f xs in ts:ls where f [] = ([], []) f (x:xs) | p x = (ls, x:ts) | otherwise = (ts:ls, []) where (ls, ts) = f xs splitWith2 p xs = let (ls, ts) = foldr f ([],[]) xs in ts:ls where f x (ls, ts) | p x = (ls, x:ts) | otherwise = (ts:ls, []) Tested with something simple like take 8 $ splitWith id (cycle [False,True]) splitWith works fine, but splitWith2 causes a stack overflow. Don't they have the same recursive structure, though?

2 1

Re: [Haskell-beginners] about beta NF in lambda calculus
by Brent Yorgey 21 Mar '09

21 Mar '09

On Sat, Mar 21, 2009 at 07:59:25PM +0000, Algebras Math wrote: > sorry, I missed something.. > > actually (\x.x) (\x.x) reduces to \x.x, they are equal under beta > reduction, isn't it? > (\x.x) (\x.x) =beta \x.x. > > so they are the same? It depends what you mean by "equal", but usually what we mean by "equal" is actual structural equality, so (\x.x) (\x.x) and \x.x are not equal, since they are different terms (one is an application of one term to another, the other is a lambda term). It makes no difference whether one reduces to the other; they are not the _same_ term so they are not equal.* However, sometimes we _don't_ want to distinguish between terms which reduce to one another; in this case we can define some sort of equivalence relation, and say, for example, S =beta T if S can be reduced to T by a series of beta reductions, or vice versa. But it is important to realize that =beta is just an equivalence relation we have defined, it is not the same thing as equality. It is quite possible to have S =beta T but S /= T, as in your example. -Brent *Technical note: actually, we usually allow terms to be equal "up to alpha equivalence", that is, you are allowed to rename bound variables. So (\x.x) and (\y.y) are equal, since you can convert between them by renaming x to y, which doesn't really change anything. > > On Sat, Mar 21, 2009 at 7:37 PM, Brent Yorgey <byorgey(a)seas.upenn.edu>wrote: > > > On Sat, Mar 21, 2009 at 07:28:48PM +0000, Algebras Math wrote: > > > hi, > > > > > > What is the different between 'in beta normal form' and 'has beta normal > > > form' ? Does the former means the current form of the term is already in > > > normal form but the latter means that it is not a normal form yet and can > > be > > > reduced to be normal form? Like \x.x is in NF and (\x.x) (\x.x) has NF? > > > > Exactly. > > > > > If above is true, I am confused why we have to distinguish the terms > > which > > > have NF and be in NF? isn't the terms have NF will eventually become in > > NF? > > > or there are some way to avoid them becoming in NF? > > > > If a term _has_ a normal form, we can be confident that we will > > eventually reach a normal form by reducing it; if a term _is in_ > > normal form, we know that reducing it will have no effect. It is > > useful to distinguish them in the same way as it is useful to > > distinguish between someone who _is currently_ at home and someone who > > is at the grocery store but has a way of getting home. (\x.x) (\x.x) > > reduces to \x.x, but they are not the same term. We could "avoid" > > having (\x.x) (\x.x) become a normal form by simply choosing not to > > reduce it. > > > > Does that help? > > > > -Brent > > _______________________________________________ > > Beginners mailing list > > Beginners(a)haskell.org > > http://www.haskell.org/mailman/listinfo/beginners > >

1 0

about beta NF in lambda calculus
by Algebras Math 21 Mar '09

21 Mar '09

hi, What is the different between 'in beta normal form' and 'has beta normal form' ? Does the former means the current form of the term is already in normal form but the latter means that it is not a normal form yet and can be reduced to be normal form? Like \x.x is in NF and (\x.x) (\x.x) has NF? If above is true, I am confused why we have to distinguish the terms which have NF and be in NF? isn't the terms have NF will eventually become in NF? or there are some way to avoid them becoming in NF? Thanks Alg

2 1

laziness and optimization
by Michael Mossey 21 Mar '09

21 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 20 Mar '09

20 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 20 Mar '09

20 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