- Beginners - Haskell.org

Hutton 2016 ex8.3a
by trent shipley 04 Sep '18

04 Sep '18

Given data Tree a = Leaf a | Node (Tree a) (Tree a) Write a leaf counter. Hutton suggests: leaves :: Tree a -> Int leaves (Leaf _) = 1 leaves (Node l r) = leaves l + leaves r I tried: leavesTrent :: Tree a -> Int leavesTrent = leaves' 0 where leaves' n (Leaf a) = n + 1 leaves' n (Node l r) = (leaves' n l), (leaves' n r) The idea is: If it is a leaf, add one to the accumulator. (Following Hutton's explanation of how sum works if defined with foldl.) If it is a tree, proceed down the left subtree recursively, until you get to a leaf, then roll up to the right subtree. The problem (among the problems) is that I don't know how to tell the compiler to do all lefts, before backing up to go right. I only know how to do that using a real operator like "+" or foo (l, r). Is that kind of no-op recursive branching possible? Trent.

2 2

Attoparsec parser and maybe type
by PICCA Frederic-Emmanuel 29 Aug '18

29 Aug '18

Hello, I have a type compose of 5 doubles data MyData = MyData Double Double Double Double Double now I have a file to parse whcih contain this | 1.0 2.0 3.0 4.0 5.0 | or | ---------no result ------------- | So I would like to create a parser which return a Maybe Mydata | 1.0 2.0 3.0 4.0 5.0 | -> Just MyData | ---------no result ------------- | -> Nothing How should I proceed I can write really trivially both parser but I do not know how to combine all this MyDataP1 = MyData <$> scientific <*> scientific NothingP = string "--------------- no result ----------------" Thanks for your help Frederic

2 2

Re: [Haskell-beginners] Beginners Digest, Vol 122, Issue 19
by Andrey Klaus 28 Aug '18

28 Aug '18

Hello everybody, I do not have many experience with haskell, but I'm programming for more then 10 years and I'm spending almost all my free time to learn FP during last 1.5 years. I have read book being discussed (Graham Hutton) and I would like to say just a couple words about it. First of all you need remember that it is book for beginners, so, IMO author would prefer to use "possible easy to understand" way instead of "most type safe" or "most canonical". And this is good for beginners because otherwise details take too many time with unreasanable low results. Hutton's style is very understandable. No even one needless detail over all the book. Code looks to me simple, concise and very clean. Despite it looks not safe sometimes, it is always perfectly reasonable. I want to say I would be happy if I were to write such code in production. When one has his own experience in haskell, she or he will be able to choose his own style. But for beginners I would surely recommend to follow Hutton's style. wbr, Andrey пн, 27 авг. 2018 г. в 15:41, <beginners-request(a)haskell.org>: > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Re: Hutton ex 7.7 and 7.8 (C Maeder) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Mon, 27 Aug 2018 10:02:48 +0200 > From: C Maeder <chr.maeder(a)web.de> > To: fa-ml(a)ariis.it > Cc: The Haskell-Beginners Mailing List - Discussion of primarily > beginner-level topics related to Haskell <Beginners(a)haskell.org> > Subject: Re: [Haskell-beginners] Hutton ex 7.7 and 7.8 > Message-ID: <7c43aeb1-80ea-5bc5-e683-002cfeeea796(a)web.de> > Content-Type: text/plain; charset=utf-8 > > Hi, see my comments below > > Am 24.08.2018 um 11:45 schrieb trent shipley: > > > > I am mostly looking for style feedback, although if there are any > > obvious logic errors, I'd be "happy" to learn about those too. > > [...] let me ignore the exercise text > > > > > type Bit = Int > > A bit is not an Int! A user-defined type (or Bool) would be type safer > (although arithmetic is missing). > > > > > byte :: Int > > byte = 8 > > > > parityByte :: Int > > parityByte = 9 > > > > bin2int :: [Bit] -> Int > > bin2int = foldr (\x y -> x + 2 * y) 0 > > use here "bit2int x" if bits are no ints. > > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2647-2649). > > Cambridge University Press. Kindle Edition. > > > > int2bin :: Int -> [Bit] > > int2bin 0 = [] > > int2bin n = n `mod` 2 : int2bin (n `div` 2) > > here you could use "even n" if bits are Bool. > > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2654-2656). > > Cambridge University Press. Kindle Edition. > > > > make8 :: [Bit] -> [Bit] > > make8 bits = addParity (take byte (bits ++ repeat 0)) > > > > -- Parity functions > > > > addParity :: [Bit] -> [Bit] > > addParity xs = if even (sum xs) > > then xs ++ [0] > > else xs ++ [1] > > appending the parity (at the end of a list) is inefficient. The parity > could be the first bit if it is not stored separately. > > > > > checkParity :: [Bit] -> Bool > > checkParity xs = (((even . sum) (take ((length xs) - 1) xs)) == > > ((even . last) xs)) || > > (((odd . sum) (take ((length xs) - 1) xs)) == > > ((odd . last) xs)) > > here is too much duplicate code! You could also use the function "init", > if the input list xs is (checked to be) non-empty. > > > > > errorParity :: [Bit] -> ([Bit], Bool) > > errorParity xs = if checkParity xs > > then (xs, checkParity xs) > > else error "Parity error" > > the result of this function is nonsense. The input (usually) does not > need to be returned and the boolean result can only be true, since the > other case fails with a runtime error. > > > > > dropParity :: [Bit] -> [Bit] > > dropParity xs = take ((length xs) - 1) xs > > this function could have been reused in checkParity. > > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2662-2663). > > Cambridge University Press. Kindle Edition. > > > > -- TRANSMISSION > > > > encode :: String -> [Bit] > > encode = concat . map (make8 . int2bin . ord) > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2673-2675). > > Cambridge University Press. Kindle Edition. > > > > chop8 :: [Bit] -> [[Bit]] > > chop8 [] = [] > > chop8 bits = (dropParity . fst . errorParity) (take parityByte bits) : > > chop8 (drop parityByte bits) > > use "splitAt" instead of take and drop. (It may not be very nice to fail > with a runtime error by using errorParity.) > > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2681-2683). > > Cambridge University Press. Kindle Edition. > > > > decode :: [Bit] -> String > > decode = map (chr . bin2int) . chop8 > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2686-2688). > > Cambridge University Press. Kindle Edition. > > > > -- channel :: [Bit] -> [Bit] > > -- channel = id > > > > channel :: [Bit] -> [Bit] > > channel = tail > > "tail" is partial! This should be documented (if this is ok). Did you > try to transmit an empty string? > > Cheers Christian > > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2696-2697). > > Cambridge University Press. Kindle Edition. > > > > transmit :: String -> String > > transmit = decode . channel . encode > > > > -- Hutton, Graham. Programming in Haskell (Kindle Locations 2694-2695). > > Cambridge University Press. Kindle Edition. > > > > > > _______________________________________________ > > Beginners mailing list > > Beginners(a)haskell.org > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > > > > > > ------------------------------ > > Subject: Digest Footer > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > > > ------------------------------ > > End of Beginners Digest, Vol 122, Issue 19 > ****************************************** >

1 0

Hutton ex 7.7 and 7.8
by trent shipley 27 Aug '18

27 Aug '18

My attempt not only compiled, but seems to run OK. (Really, a just gave it a couple of trivial tests, and said good enough. I didn't really mess with corner cases like empty lists. It was late, and I didn't want to tempt fate.) THUS, I am mostly looking for style feedback, although if there are any obvious logic errors, I'd be "happy" to learn about those too. {-- 7. Modify the binary string transmitter example to detect simple transmission errors using the concept of parity bits. That is, each eight-bit binary number produced during encoding is extended with a parity bit, set to one if the number contains an odd number of ones, and to zero otherwise. In turn, each resulting nine-bit binary number consumed during decoding is checked to ensure that its parity bit is correct, with the parity bit being discarded if this is the case, and a parity error being reported otherwise. Hint: the library function error :: String -> a displays the given string as an error message and terminates the program; the polymorphic result type ensures that error can be used in any context. 8. Test your new string transmitter program from the previous exercise using a faulty communication channel that forgets the first bit, which can be modelled using the tail function on lists of bits. Hutton, Graham. Programming in Haskell (Kindle Locations 2842-2851). Cambridge University Press. Kindle Edition. --} import Data.Char type Bit = Int byte :: Int byte = 8 parityByte :: Int parityByte = 9 bin2int :: [Bit] -> Int bin2int = foldr (\x y -> x + 2 * y) 0 -- Hutton, Graham. Programming in Haskell (Kindle Locations 2647-2649). Cambridge University Press. Kindle Edition. int2bin :: Int -> [Bit] int2bin 0 = [] int2bin n = n `mod` 2 : int2bin (n `div` 2) -- Hutton, Graham. Programming in Haskell (Kindle Locations 2654-2656). Cambridge University Press. Kindle Edition. make8 :: [Bit] -> [Bit] make8 bits = addParity (take byte (bits ++ repeat 0)) -- Parity functions addParity :: [Bit] -> [Bit] addParity xs = if even (sum xs) then xs ++ [0] else xs ++ [1] checkParity :: [Bit] -> Bool checkParity xs = (((even . sum) (take ((length xs) - 1) xs)) == ((even . last) xs)) || (((odd . sum) (take ((length xs) - 1) xs)) == ((odd . last) xs)) errorParity :: [Bit] -> ([Bit], Bool) errorParity xs = if checkParity xs then (xs, checkParity xs) else error "Parity error" dropParity :: [Bit] -> [Bit] dropParity xs = take ((length xs) - 1) xs -- Hutton, Graham. Programming in Haskell (Kindle Locations 2662-2663). Cambridge University Press. Kindle Edition. -- TRANSMISSION encode :: String -> [Bit] encode = concat . map (make8 . int2bin . ord) -- Hutton, Graham. Programming in Haskell (Kindle Locations 2673-2675). Cambridge University Press. Kindle Edition. chop8 :: [Bit] -> [[Bit]] chop8 [] = [] chop8 bits = (dropParity . fst . errorParity) (take parityByte bits) : chop8 (drop parityByte bits) -- Hutton, Graham. Programming in Haskell (Kindle Locations 2681-2683). Cambridge University Press. Kindle Edition. decode :: [Bit] -> String decode = map (chr . bin2int) . chop8 -- Hutton, Graham. Programming in Haskell (Kindle Locations 2686-2688). Cambridge University Press. Kindle Edition. -- channel :: [Bit] -> [Bit] -- channel = id channel :: [Bit] -> [Bit] channel = tail -- Hutton, Graham. Programming in Haskell (Kindle Locations 2696-2697). Cambridge University Press. Kindle Edition. transmit :: String -> String transmit = decode . channel . encode -- Hutton, Graham. Programming in Haskell (Kindle Locations 2694-2695). Cambridge University Press. Kindle Edition.

3 2

cabal.config (sandbox) with Chart package
by Jack Vice 25 Aug '18

25 Aug '18

I am attempting my first sandbox build with a cabal package (Chart) and I don't know what to put in my cabal.config file after looking at these sites: https://www.haskell.org/cabal/users-guide/developing-packages.html http://coldwa.st/e/blog/2013-08-20-Cabal-sandbox.html https://wiki.haskell.org/Cabal-Install I am getting the following build error: *Building chartHask-0.1.0.0...* *Preprocessing executable 'chartHask' for chartHask-0.1.0.0...* *[1 of 1] Compiling Main ( Main.hs, dist/build/chartHask/chartHask-tmp/Main.o )* *Main.hs:5:1: error:* * Failed to load interface for ‘Graphics.Rendering.Chart.Backend.Cairo’* * Perhaps you meant* * Graphics.Rendering.Chart.Backend.Impl (from Chart-1.9)* * Graphics.Rendering.Chart.Backend.Types (from Chart-1.9)* * Graphics.Rendering.Chart.Backend (from Chart-1.9)* * Use -v to see a list of the files searched for.* So, Maybe I'm dumb or it's not explicit (or both) on how to add a package to my cabal.config so it can find it and build. I tried adding this to my cabal.config to no avail: *documentation: True* *constraints: Chart >= 1.9* Main.hs (from Chart example: *module Main where* *import Graphics.Rendering.Chart.Easy* *import Graphics.Rendering.Chart.Backend.Cairo* *signal :: [Double] -> [(Double,Double)]* *signal xs = [ (x,(sin (x*3.14159/45) + 1) / 2 * (sin (x*3.14159/5))) | x <- xs ]* *main = toFile def "example1_big.png" $ do* * layout_title .= "Amplitude Modulation"* * setColors [opaque blue, opaque red]* * plot (line "am" [signal [0,(0.5)..400]])* * plot (points "am points" (signal [0,7..400]))* Or should I be using Stack? (probably private email or new thread question)

2 1

send string to stack ghc
by Paum B. 24 Aug '18

24 Aug '18

Hi List, It is possibile to run: stack ghc -- --interactive -XOverloadedStrings and then send to it strings (commands) externally? Thanks paum

3 7

Runtime error “Could not deduce (Integral Float) arising from a use of..”
by Jack Vice 24 Aug '18

24 Aug '18

I am trying to calculate the standard deviation for each index in a list of lists of floats. Using Ubuntu 18.04, ghc 8.0.2. I am getting the following runtime error which I have googled and still don't understand what "Integral Float" is exactly or even which parameter is causing the trouble. *Main> let z = stdDev 0 2 y x <interactive>:250:9: error: • Could not deduce (Integral Float) arising from a use of ‘stdDev’ from the context: Floating a bound by the inferred type of z :: Floating a => [a] at <interactive>:250:5-38 • In the expression: stdDev 0 (length (head (x))) y x In an equation for ‘z’: z = stdDev 0 (length (head (x))) y x Code: -- i is start index, l is length of each list, ms is list of means, -- xs is Matrix stdDev i l ms xs | i < l = sqrt(fromIntegral(sumOfMinusMeans i (ms!!i) xs) / fromIntegral(l)):(stdDev (i+1) l ms xs) | otherwise = [] --i is index, m is mean for the index sumOfMinusMeans i m (x:xs) | xs == [] = (x!!i - m)**2 | i < length x = (x!!i - m)**2 + (sumOfMinusMeans i m xs) | otherwise = 0 Types: *Main> :t stdDev stdDev :: (Floating a1, Floating a, Integral a1) => Int -> Int -> [a1] -> [[a1]] -> [a] *Main> :t sumOfMinusMeans sumOfMinusMeans :: (Eq t, Floating t) => Int -> t -> [[t]] -> t Variables: *Main> y [380.0,1.0] *Main> x [[600.0,1.0],[400.0,1.0],[170.0,1.0],[430.0,1.0],[300.0,1.0]]

3 3

Hutton 2nd ed, ex 7.6
by trent shipley 23 Aug '18

23 Aug '18

1. I got through the problem without getting so stuck I had to ask this list. But, I am disappointed in how much I had to cheat by looking up solutions on Google after making my best attempt. This higher order functions chapter is giving more trouble than any chapter so far. 2. Since getting tutoring on how to read function declarations, I'm doing better at deciphering simple declarations, but writing them myself is beyond me more often than not. 3. I feel like Hutton introduces concepts well, but with more brevity and fewer examples than would be best for me. Unfortunately, he leaves out almost all the ancillary pragmatics as exemplified by the need for "null" and "const" below. My bet is that when Hutton 2nd ed is used as a textbook in college those practical lacks get covered in lecture, problem sessions, and in mutual aid between students. Does anyone have any idea on how I might improve my performance. I am not used to having difficulty learning a computer language. (Prolog and Java Swing being exceptions.) {-- 6. A higher-order function unfold that encapsulates a simple pattern of recursion for producing a list can be defined as follows: unfold p h t x | p x = [] | otherwise = h x : unfold p h t (t x) That is, the function unfold p h t produces the empty list if the predicate p is true of the argument value, and otherwise produces a non-empty list by applying the function h to this value to give the head, and the function t to generate another argument that is recursively processed in the same way to produce the tail of the list. For example, the function int2bin can be rewritten more compactly using unfold as follows: int2bin = unfold (==0) (‘mod‘ 2) (‘div‘ 2) Redefine the functions chop8, map f and iterate f using unfold. Hutton, Graham. Programming in Haskell (Kindle Locations 2830-2842). Cambridge University Press. Kindle Edition. Basically, what you do to develop and test this question is to copy and paste extended example 7.6 Binary String Transmittter from the chapter into your text editor. Then you alter large chunks of it to use the unfold function. --} import Data.Char import Prelude hiding (iterate, map) type Bit = Int -- I had to crib the type signature unfold :: (b -> Bool) -> (b -> a) -> (b -> b) -> b -> [a] unfold p h t x | p x = [] | otherwise = h x : unfold p h t (t x) -- Hutton, Graham. Programming in Haskell (Kindle Location 2329). Cambridge University Press. Kindle Edition. -- cribbed type signature -- Had to copy (f . head), my attempt was (f head). -- I had no idea the function "null" existed before Googling the solution. -- Is Googling to learn the existence of "null" accepted pedagological practice? -- Is it a lacuna on Hutton's part? map :: (a -> b) -> [a] -> [b] map f = unfold null (f . head) tail -- had to copy the signature, although I didn't try hard to come up with it on my own. -- I had tried to use (==[]). I got the solution "False" by copying from the internet. -- I would not have gotten the word "const" without cheating from the internet. It is nowhere in Hutton's book up to this point. iterate :: (a -> a) -> a -> [a] iterate f = unfold (const False) id f -- chop8 :: [Bit] -> [[Bit]] -- chop8 [] = [] -- chop8 bits = take 8 bits : chop8 (drop 8 bits) -- Hutton, Graham. Programming in Haskell (Kindle Locations 2681-2683). Cambridge University Press. Kindle Edition. -- I attempted this first, and i pretty much got it on my own. chop8 :: [Bit] -> [[Bit]] chop8 bits = unfold (==[]) (take 8) (drop 8) bits

3 2

What should be inside the Monad or MonadTrans's type declaration? --Bound library question2.
by Anthony Lee 20 Aug '18

20 Aug '18

Hi, In Scope.hs there is one instance of Monad and one instance of MonadTrans for Scope, For the Monad instance, it is defined like this: Monad (Scope b f); For the MonadTrans instance, it is like this: MonadTrans (Scope b); Does it mean: In ">>=" the e represents (a) of (Scope b f a)? In lift function the m represents (f a) of (Scope b f a)? https://github.com/ekmett/bound/blob/master/src/Bound/Scope.hs ========================Scope.hs================================ instance Monad f => Monad (Scope b f) where #if !MIN_VERSION_base(4,8,0) return a = Scope (return (F (return a))) {-# INLINE return #-} #endif Scope e >>= f = Scope $ e >>= \v -> case v of B b -> return (B b) F ea -> ea >>= unscope . f {-# INLINE (>>=) #-} instance MonadTrans (Scope b) where lift m = Scope (return (F m)) {-# INLINE lift #-}

2 1

Re: [Haskell-beginners] Bound library questions (David McBride)
by Anthony Lee 19 Aug '18

19 Aug '18

Now I understand it. Thanks a lot! Anthony On Sat, Aug 18, 2018 at 5:34 AM <beginners-request(a)haskell.org> wrote: > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Re: Beginners Digest, Vol 122, Issue 6 (Anthony Lee) > 2. Re: Bound library questions (David McBride) > 3. Empty list and null (trent shipley) > 4. Re: Empty list and null (Ut Primum) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Fri, 17 Aug 2018 09:21:47 -0400 > From: Anthony Lee <anthonynlee(a)gmail.com> > To: beginners(a)haskell.org > Subject: Re: [Haskell-beginners] Beginners Digest, Vol 122, Issue 6 > Message-ID: > <CA+pBo5FSLqbgC= > L9bONcCb0y+UPSGq6jpVgq60ouKUNk4xNv3w(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > The source code is here: https://github.com/ekmett/bound/ > > On Fri, Aug 17, 2018 at 8:41 AM <beginners-request(a)haskell.org> wrote: > > > Send Beginners mailing list submissions to > > beginners(a)haskell.org > > > > To subscribe or unsubscribe via the World Wide Web, visit > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > > or, via email, send a message with subject or body 'help' to > > beginners-request(a)haskell.org > > > > You can reach the person managing the list at > > beginners-owner(a)haskell.org > > > > When replying, please edit your Subject line so it is more specific > > than "Re: Contents of Beginners digest..." > > > > > > Today's Topics: > > > > 1. Bound library questions (Anthony Lee) > > > > > > ---------------------------------------------------------------------- > > > > Message: 1 > > Date: Fri, 17 Aug 2018 06:46:52 -0400 > > From: Anthony Lee <anthonynlee(a)gmail.com> > > To: beginners(a)haskell.org > > Subject: [Haskell-beginners] Bound library questions > > Message-ID: > > <CA+pBo5HVraf_8jbs15bR6QAy1S7=z_u-3KBwT= > > c3sqkAgc0m5Q(a)mail.gmail.com> > > Content-Type: text/plain; charset="utf-8" > > > > In Scope.hs there are some functions I feel difficult to understand, > > Why fmap/foldmap/traverse is applied three times? > > > > instance Functor f => Functor (Scope b f) where > > fmap f (Scope a) = Scope (fmap (fmap (fmap f)) a) > > {-# INLINE fmap #-} > > > > -- | @'toList'@ is provides a list (with duplicates) of the free > variables > > instance Foldable f => Foldable (Scope b f) where > > foldMap f (Scope a) = foldMap (foldMap (foldMap f)) a > > {-# INLINE foldMap #-} > > > > instance Traversable f => Traversable (Scope b f) where > > traverse f (Scope a) = Scope <$> traverse (traverse (traverse f)) a > > {-# INLINE traverse #-} > >

1 0