- Beginners - Haskell.org

Continuations
by Cary Cherng 01 Jan '15

01 Jan '15

I read (http://en.wikibooks.org/wiki/Haskell/Continuation_passing_style) that in some circumstances, CPS can be used to improve performance by eliminating certain construction-pattern matching sequences (i.e. a function returns a complex structure which the caller will at some point deconstruct). And that attoparsec is an example of this. I don't see exactly how CPS gives rise to concrete examples of performance gains. Moreover how does this arise in parsing for example with attoparsec as mentioned. I also encountered various web frameworks such as mflow that are based on continuations. How a typical http restful system is made into something based around continuations is not something that is obvious to me. And what is gained from that?

4 3

Re: [Haskell-beginners] Long time no Haskell....simple typeclass question
by Nicholls, Mark 31 Dec '14

31 Dec '14

This is the basic problem... I have a data type, that has some functions that require typeclass constraints (this example doesn't...but that's not the point). I have a typeclass, and I want to declare my datatype inhabits that type class.... > data Func a b = Func (a->b) > exeFunc :: (Ord a) => Func a b -> a -> b > exeFunc (Func g) = g > class IFunc f where > exe :: f a b -> a -> b > instance IFunc Func where > exe = exeFunc Follow your nose and obviously "No instance for (Ord a) arising from a use of 'exeFunc'" But how do I constain "a" in the instance declaration, when "a" doesn't even appear CONFIDENTIALITY NOTICE This e-mail (and any attached files) is confidential and protected by copyright (and other intellectual property rights). If you are not the intended recipient please e-mail the sender and then delete the email and any attached files immediately. Any further use or dissemination is prohibited. While MTV Networks Europe has taken steps to ensure that this email and any attachments are virus free, it is your responsibility to ensure that this message and any attachments are virus free and do not affect your systems / data. Communicating by email is not 100% secure and carries risks such as delay, data corruption, non-delivery, wrongful interception and unauthorised amendment. If you communicate with us by e-mail, you acknowledge and assume these risks, and you agree to take appropriate measures to minimise these risks when e-mailing us. MTV Networks International, MTV Networks UK & Ireland, Greenhouse, Nickelodeon Viacom Consumer Products, VBSi, Viacom Brand Solutions International, Be Viacom, Viacom International Media Networks and VIMN and Comedy Central are all trading names of MTV Networks Europe. MTV Networks Europe is a partnership between MTV Networks Europe Inc. and Viacom Networks Europe Inc. Address for service in Great Britain is 17-29 Hawley Crescent, London, NW1 8TT.

1 2

ghc prelude home
by Doug McIlroy 29 Dec '14

29 Dec '14

Where can I find the full ghc prelude? In the local installation I was able to find only .hi files, not .hs. Poking around github, I found module Prelude.hs. It's a skeleton that imports many submodules, which I wasn't clever enough to find. \ Doug McIlroy

7 11

Generalizing traversal of expressions with changes on specific nodes
by Antoni Boucher 26 Dec '14

26 Dec '14

Hi. I read the lectures from the CIS194 course (version fall 2014) and I wanted to have some comments on my solution to the Exercise 7 of the Homework 5. Here is the question: Exercise 7 (Optional) The distribute and squashMulId functions are quite similar, in that they traverse over the whole expression to make changes to specific nodes. Generalize this notion, so that the two functions can concentrate on just the bit that they need to transform. (You can see the whole homework here: http://www.seas.upenn.edu/~cis194/hw/05-type-classes.pdf) Here is my squashMulId function from Exercise 6: squashMulId :: (Eq a, Ring a) => RingExpr a -> RingExpr a squashMulId AddId = AddId squashMulId MulId = MulId squashMulId (Lit n) = Lit n squashMulId (AddInv x) = AddInv (squashMulId x) squashMulId (Add x y) = Add (squashMulId x) (squashMulId y) squashMulId (Mul x (Lit y)) | y == mulId = squashMulId x squashMulId (Mul (Lit x) y) | x == mulId = squashMulId y squashMulId (Mul x y) = Mul (squashMulId x) (squashMulId y) And here is my solution to Exercise 7: distribute :: RingExpr a -> RingExpr a distribute = transform distribute' where distribute' (Mul x (Add y z)) = Just $ Add (Mul x y) (Mul x z) distribute' (Mul (Add x y) z) = Just $ Add (Mul x z) (Mul y z) distribute' _ = Nothing squashMulId :: (Eq a, Ring a) => RingExpr a -> RingExpr a squashMulId = transform simplifyMul where simplifyMul (Mul x (Lit y)) | y == mulId = Just $ squashMulId x simplifyMul (Mul (Lit x) y) | x == mulId = Just $ squashMulId y simplifyMul _ = Nothing transform :: (RingExpr a -> Maybe (RingExpr a)) -> RingExpr a -> RingExpr a transform f e | Just expr <- f e = expr transform _ AddId = AddId transform _ MulId = MulId transform _ e@(Lit n) = e transform f (AddInv x) = AddInv (transform f x) transform f (Add x y) = Add (transform f x) (transform f y) transform f (Mul x y) = Mul (transform f x) (transform f y) Is there a better way of doing such generalization? Thanks for your help.

1 0

Google Summer of Code
by Njagi Mwaniki 24 Dec '14

24 Dec '14

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 Which books or resources or libraries should one read to get ready for the Google summer of code? Also which projects would be easiest to work on for beginners? Anything that would make one ready for Google summer of code and complete their project with ease. I'm currently taking cs194 from upenn online http://www.seas.upenn.edu/~cis194/lectures.html -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQJ8BAEBCgBmBQJUmDLFXxSAAAAAAC4AKGlzc3Vlci1mcHJAbm90YXRpb25zLm9w ZW5wZ3AuZmlmdGhob3JzZW1hbi5uZXRGMjlGREM4Qjk5M0I2NEFEODkwMzFEQkRB MDNCNjA0MzJCQzVCQjdEAAoJEKA7YEMrxbt9H7MP/j89OarC7pjq80dwRT8OltbW d1xj6wabb7RsvRH0rrvo5iBbSG7PNTq22cEbhlWukBToCRpo7YKX75EqLVuYwXl+ wPnTbKrerbsslslQruDkDkV3ilXA59uVFK7pLcbU9CN0TjAdUEA30ih+UAQihkjc +knhhB4iBAK/wYzN8VUwkfSCzxEb1YSZR5Ax99deAP7QzjmEaWwf9do9LLtrQZUu +Z9nl5HehUC3A9ESR/9DDCVvAKOQEQNSuhYGWI2HbzviXFg4Q4++6ZgHCg01/1m8 HeZPXzj+P1r8Is1KU4G88rK2oaLkjHWBkix703LzWzwdhu9pN2KN4SHshzdbajbm efVpE6/cPTjd1UtHZYHw5hwqfFrXVUkXgNuMAb7LA3CAy5HtZGOelHTyhgcouaVw TuGaYqDmF4E4Dw/f9HpvifvK4C/tBEXObXMLc28eXScdBa1HLZvKbkcEN1LtS0Gk KptDtPV7QWmSeRIoykhhKti53EuLaPrHZImFUwW8bxT1hZXAC04LoUKyYXnek8Sq tlOKEWnmgSPSanHQXSi3s8D39KJLX1W7Itcuxg6urwBrKB7BjWOO7ns1EVJKCw2X RsMorWwX2p5OvJYQrfTjfH6H9sfmXfknlyRpdp4DJ7qIlrQOKSpM8atU9uKvXyuI haO3utPRp68x5ItCi6G0 =9H6s -----END PGP SIGNATURE-----

3 2

Getting started with Haskell
by Sagar Srivastava 23 Dec '14

23 Dec '14

Hello All! I'm Sagar, from India.I'm a sophomore at BITS Pilani,Hyderabad ,currently pursuing a B.E(Hons) degree in Computer Science. I've just started learning Haskell and i was aiming to participate in this year's Google Summer of Code,and so i was wondering if i could get comfortable enough with the language ,given enough effort so that i might be able to contribute to the project and maybe participate in GSoC with this organization. Also,wishing all of you a Merry Christmas and a Happy New Year! :) Regards, Sagar

5 5

Does/How does GHC/Haskell optimize this ('almost identical associative expressions', pattern matching reordering)
by Pascal Knodel 18 Dec '14

18 Dec '14

Hi all, a) I've learned that Haskell uses graphs (graph reduction) to do optimizations / 'sharing'. Calculation example: -- (1 + 2) + (1 + 2) -- ~> 3 + 3 -- ~> 6 in contrast to -- (1 + 2) + (3 + 0) -- ~> 3 + (3 + 0) -- ~> 3 + 3 -- ~> 6 What does it do in a case like: ... min 0 1 ... min 1 0 ..., or: (1 + 2) + (2 + 1) where a function definition is used which has the same result in both cases, but arguments are flipped. This is a simple example for a very general problem. What does the underlying system do about it? (a1) Can it detect and optimize it? In the example it would be easy to reduce it to the relations that define the min function. Is GHC able to detect it? (a2) Is there a super language to Haskell, like an speci. assembler in other paradigms, that could split code into even smaller pieces? (a3) What happens at run-time, for example: ... min a b ... min b a ...? b) About 'pattern matching': Does Haskell reorder patterns for optimization? How/what technique does it use there? Example: ... f [] = ... f (a : as) = ... f ( b(a) ) ... ... VS. ... f (a : as) = ... f ( b(a) ) ... f [] = ... ... If Haskell does pattern matching like I've been told: top down, the first definition would statistically be inefficient, because recursive functions are normally called with the intension to do some (recursive) calculations. I tested (*) it (without optimization). What do I need to know to understand this behavior? * Tests were (+RTS -<test> -RTS): -------------------- snip -------------------- module Test where f1 :: String -> String f1 [] = [] f1 [a1] = [a1] f1 [a1,a2] = [a1,a2] f1 [a1,a2,a3] = [a1,a2,a3] f1 [a1,a2,a3,a4] = [a1,a2,a3,a4] f1 [a1,a2,a3,a4,a5] = [a1,a2,a3,a4,a5] f1 [a1,a2,a3,a4,a5,a6] = [a1,a2,a3,a4,a5,a6] f1 (a1 : a2 : a3 : a4 : a5 : a6 : a7 : as) = f1 as f2 :: String -> String f2 (a1 : a2 : a3 : a4 : a5 : a6 : a7 : as) = f2 as f2 [a1,a2,a3,a4,a5,a6] = [a1,a2,a3,a4,a5,a6] f2 [a1,a2,a3,a4,a5] = [a1,a2,a3,a4,a5] f2 [a1,a2,a3,a4] = [a1,a2,a3,a4] f2 [a1,a2,a3] = [a1,a2,a3] f2 [a1,a2] = [a1,a2] f2 [a1] = [a1] f2 [] = [] p1 :: IO () p1 = print $ f1 [' ' | _ <-[1 .. 10^9] ] -- 63.87 secs p2 :: IO () p2 = print $ f2 [' ' | _ <-[1 .. 10^9] ] -- 62.68 secs -------------------- snip --------------------

1 0

Deploying a haskell application (not a webapp)
by Alan Buxton 18 Dec '14

18 Dec '14

Hi I have created an application using cabal that now installs fine and runs fine on my dev machine. I now want to deploy this application onto a separate server. This is not a webapp. Try as I might, Google will not point me in the direction of how to do this, apart from loads of links to Keter which is not what I want (there is no nginx or any other web server involved). Any advice on the neatest way to do this? Thanks Alan

12 18

structural induction, two lists, simultaneous
by Pascal Knodel 18 Dec '14

18 Dec '14

Hi list, Proposition: map f (ys ++ zs) = map f ys ++ map f zs (Haskell, the craft of functional programming, exercise 11.31) Almost every time I'm asked to do (structural) induction over multiple 'things', in this example lists, I don't know how to do it. (I encountered similar difficulties when I worked through chapter 9, see https://github.com/pascal-knodel/haskell-craft/tree/master/Chapter%209 , ex. 9.5 , https://github.com/pascal-knodel/haskell-craft/blob/master/Chapter%209/E%27…) I think my proof in this case isn't formally correct. It feels like it isn't. I would like to do the example with your help, so that I feel a little bit safer. Let's start with the base case. If I have two lists, do I select one, say ys := [] . Only one or one after another? Or both 'parallel'? I could state ys ++ zs := [] too, does it help? I could imagine that the proposition could be expanded to something like map f (l1 ++ l2 ++ ... ++ lN) = map f ys ++ map f zs = map f l1 ++ map f l2 ++ ... ++ map f lN And I could imagine that it is possible to do induction over more than two lists too. What is the reason why we can do it over two 'objects' at the same time? How do I start? Can you explain this to me? Attempt: -- --------------- -- 1. Proposition: -- --------------- -- -- map f (ys ++ zs) = map f ys ++ map f zs -- -- -- Proof By Structural Induction: -- ------------------------------ -- -- -- 1. Induction Beginning (1. I.B.): -- --------------------------------- -- -- -- (Base case 1.) :<=> ys := [] -- -- => (left) := map f (ys ++ zs) -- | (Base case 1.) -- = map f ([] ++ zs) -- | ++ -- = map f zs -- -- -- (right) := map f ys ++ map f zs -- | (Base case 1.) -- = map f [] ++ map f zs -- | map -- = map f zs -- -- -- => (left) = (right) -- -- ✔ -- -- -- 1. Induction Hypothesis (1. I.H.): -- ---------------------------------- -- -- For an arbitrary, but fixed list "ys", the statement ... -- -- map f (ys ++ zs) = map f ys ++ map f zs -- -- ... holds. -- -- -- 1. Induction Step (1. I.S.): -- ---------------------------- -- -- -- (left) := map f ( (y : ys) ++ zs ) -- | ++ -- = map f ( y : ( ys ++ zs ) ) -- | map -- = f y : map f ( ys ++ zs ) -- | (1. I.H.) -- = f y : map f ys ++ map f zs -- | map -- = map f (y : ys) ++ map f zs -- -- -- (right) := map f (y : ys) ++ map f zs -- -- -- => (left) = (right) -- -- -- ?■? (1. Proof) But in this 'proof attempt' only "ys" was considered (1. I.H.). What do I miss? Pascal

3 4

Anyone here self-studying upenn's CIS 552 taught by Benjamin Pierce
by chao chu 17 Dec '14

17 Dec '14

Hi, The course website: http://www.seas.upenn.edu/~cis552/ I found the lecture and lab materials are very good and I am self-studying the course by reading the lecture notes and doing the labs on my own. Just want to check if anyone is also following the course so that we can form a study group to discuss whatever we want about the course and also about learning haskell. Thanks & Regards, -- ChuChao

3 2