- Beginners - Haskell.org

Question about class declaration
by Rafael Gustavo da Cunha Pereira Pinto 24 Jul '09

24 Jul '09

Hi folks, Once in a while I stumble upon declarations like this: class EditAction e a | e -> a where apply :: a -> e -> a Why is the vertical bar there? I understand that => defines a context, but can't find what is the "|" for. Thanks Rafael Gustavo da Cunha Pereira Pinto

3 3

haskell problem
by B1lal 23 Jul '09

23 Jul '09

im having problem with this Haskell functions female, male :: String -> Bool for finding out the gender for a given name which can be inferred from the title. For example, gender> female "Ms. Green" True gender> female "King Arthur" False gender> male "Mr. Scrooge" True gender> female "Miss Beatrix Potter" True

4 3

Double's
by Thomas Friedrich 22 Jul '09

22 Jul '09

Hi everybody, please have a look at the following lines of code: x :: [Double] x = [2,4,6,8,10] p :: [Double] p = [0.05, 0.2, 0.35, 0.3, 0.1] expectation :: Double expectation = sum $ zipWith (*) x p variance :: Double variance = sum $ zipWith f x p where f i p = (i - expectation)^2 * p when I load this into ghci I get the following: *Main> expectation 6.3999999999999995 *Main> expectation == 6.4 False *Main> variance 4.24 *Main> Why does 'expectation' get evaluated to 6.39999... instead of 6.4?? This is very strange. I have another example which is even more annoying: Have a look at the following code: import qualified Data.Map as M newtype Distribution a = Distribution (M.Map a Double) isDistribution :: Distribution a -> Bool isDistribution (Distribution d) = sum (M.elems d) == 1 uniform :: Ord a => [a] -> Distribution a uniform xs = Distribution (M.fromList (map go xs)) where go i = (i, 1 / fromIntegral (length xs)) When I load this into ghci I get the following: *Probability> isDistribution $ uniform [1..6] False *Probability> (\(Distribution d) -> sum (M.elems d)) $ uniform [1..6] 0.9999999999999999 *Probability> I mean ... hey, what is going on here? Is there any way of getting around this? Cheers, Thomas

5 6

Rank beginner question about debugging
by Ben Wise 22 Jul '09

22 Jul '09

Folks, I'm a rank beginner in Haskell, and though Haskell seems like a great language to start using, I've got a serious concern about debugging. In about 15 years of Lisp experience, then 15 years of C++, I've gotten pretty accustomed to the idea of using a debugger with lots of pre- and post-conditions on functions, breakpoints, stack trace, and variable inspection -- even though it gets tricky with delayed evaluation, macros, etc. in Lisp! So I don't understand how serious programmers can work on large projects in Haskell with nothing but compiler type-checking and QuickCheck. Yet they get it done, so I must be missing something. Things like the Haskell version of Eclipse seem to provide nothing but syntax coloring and pass-through to 'make': no break points, stack trace, or variable inspection that I can find. Is there some serious IDE (even "emacs + gdb" is serious enough for me) I'm missing? Do Haskell shops develop their own home-grown tools, or do they do something completely different? -- Ben P. Wise, PhD GPG: 0xCAF514E1

3 2

dependent types
by pat browne 21 Jul '09

21 Jul '09

{- Hi, Consider the following Haskell data, class and instance definitions The intended semantics are: Two objects are equal if they have the same name. The type of the name depends on the type of the object -} data Object a = Object a class Named o n | o -> n where name :: o -> n instance (Eq n, Named o n) => Eq o where o1 == o2 = name(o1) == name(o2) {- I have three questions about these definitions. 1) Does the above code capture the intended meaning? 2) Does Object a *fit* the Named class?, or do I need a different sort of Object? 3) How would I write an instance of Named that implements the name function correctly. Thomson[1] shows how to do this for non-dependent types [1]Haskell: The Craft of Functional Programming, Second Edition, Page 272 -}

4 5

QuickCheck help
by Patrick LeBoutillier 20 Jul '09

20 Jul '09

Hi, I'm writing a small library to manipulate IPv4 addresses and masks. The core types are as such: data IPv4Host = IPv4Host { hbytes :: Word32 } deriving (Eq) data IPv4Mask = IPv4Mask { mbytes :: Word32 } deriving (Eq) I'm trying to test my library using QuickCheck. My test script looks like this so far: import Test.QuickCheck.Batch import Test.QuickCheck import Net.IPv4 prop_host_read_show :: Int -> Bool prop_host_read_show i = let w = fromIntegral i h = IPv4Host w in read . show $ h == h options = TestOptions { no_of_tests = 100 , length_of_tests = 0 , debug_tests = True } main = do runTests "IPv4Host" options [ run prop_host_read_show ] I'm generating arbitrary Ints that are then converted to Word32 values. The problem is that for 100 tests, all the generated Ints seem to be below +/- 100. How do I get the Ints to be more evenly distributed over the entire 32 bit range? I tried making Word32 and instance if Arbitrary using choose (0, 0xFFFFFFFF) but I got the same results... Thanks, Patrick -- ===================== Patrick LeBoutillier Rosemère, Québec, Canada

2 1

where scope
by I. J. Kennedy 20 Jul '09

20 Jul '09

GHC complains that u is out of scope in the following definition: f n = let u = [1..n] in g n where g x = u Why? I understand that it's "just the way Haskell works", but I'm wondering about the rationale of the language designers when deciding on this scoping behavior.

3 2

Talking betwean the parsers.
by Maciej Piechotka 19 Jul '09

19 Jul '09

I have a data structure of data Monad m => NntpConnection m = NntpConnection { input :: ByteString, output :: ByteString -> m () } I'd like to create echo structure such that the goes to output is going to (lazy) input. For sure it is possible to use network and IO monad - is is possible to do it purely? Regards

2 4

Sorting arrays
by Jon Harrop 18 Jul '09

18 Jul '09

I cannot find a sort function for arrays in the standard library. Is there one? -- Dr Jon Harrop, Flying Frog Consultancy Ltd. http://www.ffconsultancy.com/?e

2 1

Parallelizing array-based functions
by Jon Harrop 17 Jul '09

17 Jul '09

If you have a function that mutates the elements of an array in-place and leverages parallelism by recursively subdividing the problem and mutating parts of the array separately, can this be expressed in Haskell? In-place quicksort and many of the numerical methods from linear algebra fall into this category. -- Dr Jon Harrop, Flying Frog Consultancy Ltd. http://www.ffconsultancy.com/?e

2 1