- Beginners - Haskell.org

Disjunction
by Russ Abbott 10 Dec '10

10 Dec '10

I recently was writing code long these lines. f x = p1 x || p2 x || ... || pn x I would have liked to write that in pointfree form but couldn't find a library function to do it. I created this. disj :: [a -> Bool] -> a -> Bool disj ps = (\x -> or $ map ($x) ps) disj2 p1 p2 = disj [p1, p2] disj3 p1 p2 p3 = disj [p1, p2] disj4 p1 p2 p3 p4 = disj [p1, p2] ... With that I can write my function as follows. f = disj pi p2 p3 ... pn Is there a standard way to do this? * -- Russ*

4 4

DPH help
by Luca Ciciriello 09 Dec '10

09 Dec '10

Hi All. I'm trying to load in GHCi the following code: {-# LANGUAGE Arrows #-} {-# LANGUAGE PArr, ParallelListComp #-} module Test where import Control.Arrow import Control.Parallel dotp :: Num a => [:a:] -> [:a:] -> a dotp xs ys = sumP [:x * y | x <- xs | y <- ys:] ...... Then I get the error: Not in scope 'sumP'. What I have to import to avoid this error? Where is defined sumP? Thanks in advance for any answer. Luca

2 1

A newbie question
by Mianlai Zhou 08 Dec '10

08 Dec '10

Hello All, Today I wrote my first Haskell program, which is module Main where f 1 = 1 f n = n*f(n-1) main = putStrLn (show (f 5)) After compilation, this program runs with no problem and gives 120 (which is correct). I have two questions though: 1. What does "where" in line 2 mean? Why I should put it here in this place? If there is no "where" here, the program cannot run. But what is the syntactical meaning of "where"? 2. Why this module can end without an "end" sentence? And what are the blank lines treated as? Thank you for your answer, well, in advance. These are newbie questions indeed. Best wishes, Mr. Zhou

2 2

Architecture and monads
by Amy de Buitléir 08 Dec '10

08 Dec '10

Until recently, the choice of whether or not to use monads was easy. I didn't understand them, so I avoided them! But now that I think I understand enough to begin to use them, I have a different problem: I don't have the experience to know when using them is a good idea, and when it's overkill. This is my first serious Haskell project, and I would appreciate any advice. Here's the scenario: I'm developing a virtual world with alife creatures. At one extreme, I guess I could use the State monad for everything that has state, right down to the neurons in their brains. (I assume that would be overkill.) At the other extreme, I could do without the State monad altogether, and just have functions that take a creature, let it have an experience, and return a new creature. I guess somewhere in-between there's a happy medium. Perhaps I should us the State monad for the creatures, but not for anything lower-level than that. Or maybe use it for the creatures and their brains. One issue that complicates things slightly is that a *lot* of the processing I'm doing requires random numbers. The neurons don't require any randomness, but the brain as a whole does. And reproduction requires randomness down at the DNA level. The code works, but I feel it's a bit messy because of needing randomness in so many places, and I'd like to clean up the design a bit. Generally speaking, is it best to go for the "bon-bon" approach, with a pure functional core, and a monadic layer on the outside?

2 2

whats up
by David Schonberger 08 Dec '10

08 Dec '10

making all this money has always been a dream for me i found this all out on a web site off the internet one of my new hobby's is traveling i was making money immediately http://www.cnbc1000news.com

1 0

Inferring functions from parameter types
by Russ Abbott 07 Dec '10

07 Dec '10

Is there any theoretical reason why GHC (or Haskell) doesn't permit functions to be inferred from their parameter types? For example, if I write null Data.Set.empty I get a diagnostic saying Ambiguous occurrence `null' It could refer to either `List.null', imported from Data.List at ... or `Map.null', imported from Data.Map at ... or `IntSet.null', imported from Data.IntSet at ... Why doesn't GHC figure it out? More generally it would be nice to be able to define: f :: Type1 -> ResultType1 f :: Type2 -> ResultType2 and expect GHC to select the appropriate f based on the argument and implied result types. Even if the type can't always be determined, why not do it when possible and issue a complaint when it can't? * -- Russ *

2 1

defining 'init' in terms of 'foldr'
by Paul Higham 07 Dec '10

07 Dec '10

Not sure if this thread is still active but I also struggled with this same exercise. I offer the following solution as a thing to shoot at: myInit :: [a] -> [a] myInit ys = foldr snoc [] $ (\(x:xs) -> xs) $ foldr snoc [] ys where snoc = (\x xs -> xs ++ [x]) Note that snoc is defined at the top of the same page as the exercise in Simon's book. ::paul

3 3

gtk2hs website
by Venanzio Capretta 06 Dec '10

06 Dec '10

Hi everybody, I was starting to learn how to use gtk2hs. Unfortunately, the web site for it has suddenly disappeared. It used to be at "http://www.haskell.org/gtk2hs/". The information on the Haskell page "http://www.haskell.org/haskellwiki/Gtk2Hs" is not enough to understand how the library works. Does anybody know how I can access the old site? Thanks, Venanzio

2 1

Exception back trace
by Russ Abbott 06 Dec '10

06 Dec '10

Hi, I am in the midst of debugging and got an exception: *** Exception: Prelude.minimum: empty list That's all it said. There was no information about where the exception occurred. Is it possible to ask for more information, preferably including a stack trace? Thanks. * -- Russ *

5 5

Re: [Haskell-beginners] defining 'init' in terms of 'foldr'
by Hein Hundal 05 Dec '10

05 Dec '10

I am trying to understand the differences between two different solutions to the problem of expressing init in terms of foldr. The two solutions are called heinInit and chaddiInit. The heinInit does not work on infinite lists. The chaddiaiInit function does work on infinite lists. heinInit v = fromJust $ foldr f Nothing v where f a Nothing = Just [] f a (Just v) = Just (a:v) chaddaiInit v = fromJust $ foldr f Nothing v where f x xs = Just (case xs of Nothing -> []; Just ys -> x:ys) Here is my guess at the "trace" of the chaddaiInit code. 1) head (chaddaiInit [1..]) 2) head (fromJust $ foldr f Nothing [1..]) 3) head (fromJust $ f 1 (foldr f Nothing [2..])) 4) head (fromJust $ Just (case (foldr f Nothing [2..]) of Nothing -> []; Just ys -> 1:ys)) 5) head (case (foldr f Nothing [2..]) of Nothing -> []; Just ys -> 1:ys) 6) head (case (f 2 (foldr f Nothing [3..])) of Nothing -> []; Just ys -> 1:ys) 7) head (case (Just (case (foldr f Nothing [3..]) of Nothing -> []; Just ys -> 2:ys)) of Nothing -> []; Just ys -> 1:ys) 8) head (1:(case (foldr f Nothing [3..]) of Nothing -> []; Just ys -> 2:ys)) 9) 1 Here is my guess at the "trace" of the heinInit code. myinit v = fromJust $ foldr f Nothing v where f a Nothing = Just [] f a (Just v) = Just (a:v) 1) head (heinInit [1..]) 2) head (fromJust $ foldr f Nothing [1..]) 3) head (fromJust $ f 1 (foldr f Nothing [2..]) 4) head (fromJust $ f 1 (f 2 (fold f Nothing [3..]) 5) head (fromJust $ f 1 (f 2 (f 3 (fold f Nothing [4..]) And it just keeps going. Is this the right idea? Are my "traces" a reasonable estimate of how Haskell evaluates those expressions? Cheers, Hein

2 1