October 2011 - Beginners

Re: [Haskell-beginners] recursion and pattern matching
by Alia 18 Oct '11

18 Oct '11

[apologies if this is a duplicate, as my prior communication may or may not be lost in the ether] Ok, so having spent some further time on this. Methinks I have a solution below. The aha moment occurred when I fell upon the definition of foldr and then looked at the recursive functions. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) treeFold is implemented two ways, the first is as Brent advised, the second places the accumulator after the function and follows from foldr. I suspect the first approach is probably more practical because you can curry the accumulator away. The final check function verifies the equivalence of recursive and fold friendly functions. It was a cool exercise in all. Thanks Brent! (-: AK <Test.hs> module Test where data Tree a b = EmptyTree | Node a b [Tree a b] deriving (Show, Read, Eq) t = Node "goal" 1.0 [ Node "a2" 0.5 [ Node "a3" 3.0 [ Node "a4" 1.0 [ Node "a5" 1.0 [] ] ] ], Node "b2" 0.5 [ Node "b3.1" 2.0 [], Node "b3.2" 2.0 [ Node "b4" 10.0 [] ] ] ] maximum0 [] = 0 maximum0 xs = maximum xs sumTree :: (Num b) => Tree a b -> b sumTree EmptyTree = 0 sumTree (Node _ value children) = value + sum (map sumTree children) count :: Tree a b -> Int count EmptyTree = 0 count (Node _ value children) = 1 + sum (map count children) depth :: Tree a b -> Int depth EmptyTree = 0 depth (Node _ value children) = 1 + maximum0 (map depth children) treeFold :: c -> (a -> b -> [c] -> c) -> Tree a b -> c treeFold acc f EmptyTree = acc treeFold acc f (Node name value children) = f name value (map (treeFold acc f) children) treeFold' :: (a -> b -> [c] -> c) -> c -> Tree a b -> c treeFold' f z EmptyTree = z treeFold' f z (Node name value children) = f name value (map (treeFold' f z) children) sumTree' :: String -> Double -> [Double] -> Double sumTree' name value xs = value + sum xs count' :: (Num c) => a -> b -> [c] -> c count' name value xs = 1 + sum xs depth' :: (Num c, Ord c) => a -> b -> [c] -> c depth' name value xs = 1 + maximum0 (xs) check = [ count t == treeFold' count' 0 t , sumTree t == treeFold' sumTree' 0 t , depth t == treeFold' depth' 0 t ] <Test.hs>

1 0

Re: [Haskell-beginners] Resources for Learning
by Paulo Pocinho 18 Oct '11

18 Oct '11

Hi again. The link I gave has some very interesting lectures on haskell. It is not really for someone beginning to program but I believe imperative programmers can catch up quickly. For real beginners it is best to search haskell.org or read an introductory book such as learnyouahaskell.com On 18 October 2011 21:50, ranveer raghuwanshi <ranveer.raghu(a)gmail.com> wrote: > Are these basic video tutorials.? > I am completely new to the world of haskell and functional programming. > > On Wed, Oct 19, 2011 at 2:10 AM, Paulo Pocinho <pocinho(a)gmail.com> wrote: >> >> http://channel9.msdn.com/Tags/haskell >> >> On 18 October 2011 21:28, ranveer raghuwanshi <ranveer.raghu(a)gmail.com> >> wrote: >> > Can someone direct me to good video tutorial resources related to >> > haskell.? >> > _______________________________________________ >> > Beginners mailing list >> > Beginners(a)haskell.org >> > http://www.haskell.org/mailman/listinfo/beginners >> > >> > > >

1 0

Resources for Learning
by ranveer raghuwanshi 18 Oct '11

18 Oct '11

Can someone direct me to good video tutorial resources related to haskell.?

2 1

Snap layouts | app examples
by Jakub Oboza 18 Oct '11

18 Oct '11

Dear Haskellers Can you provide me with example of layout'ing system for snap. I mean something like layouts in "rails" So if you have a standard heist layout for actions like index, show, edit i would like to have a global application layout that will have javascripts/css tags and rest of "action" layouts will be just yield inside of it. I don't know if this description is perfect :D. ps. example of medium size snap applications would also be nice. Kind regards Jakub Oboza

1 0

Re: [Haskell-beginners] Beginners Digest, Vol 40, Issue 27
by Bob Walters-LT 18 Oct '11

18 Oct '11

please unsubscribe On Oct 18, 2011, at 6:04 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://www.haskell.org/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: newbie: Monad, equivalent notation using > Control.Monad.guard (Brent Yorgey) > 2. Re: recursion and pattern matching (Brent Yorgey) > 3. Re: newbie: Monad, equivalent notation using > Control.Monad.guard (Hugo Ferreira) > 4. Weird (++) behavior when adding 2 vectors (Alexander Raasch) > 5. Re: Weird (++) behavior when adding 2 vectors (Vlad Hanciuta) > 6. Re: Weird (++) behavior when adding 2 vectors (Lorenzo Bolla) > 7. Re: Weird (++) behavior when adding 2 vectors (Amy de Buitl?ir) > 8. Re: Weird (++) behavior when adding 2 vectors (Alexander Raasch) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Tue, 18 Oct 2011 06:52:01 -0400 > From: Brent Yorgey <byorgey(a)seas.upenn.edu> > Subject: Re: [Haskell-beginners] newbie: Monad, equivalent notation > using Control.Monad.guard > To: beginners(a)haskell.org > Message-ID: <20111018105201.GA1102(a)seas.upenn.edu> > Content-Type: text/plain; charset=us-ascii > > On Tue, Oct 18, 2011 at 10:52:57AM +0100, Hugo Ferreira wrote: >> Hello, >> >> On 10/17/2011 05:22 PM, Brent Yorgey wrote: >>> On Mon, Oct 17, 2011 at 04:18:05PM +0100, Hugo Ferreira wrote: >>>> Hello, >>>> >>>> I came across the following code: >>>> >>>> ngrams'' :: Int -> [a] -> [[a]] >>>> ngrams'' n l = do >>>> t<- Data.List.tails l >>>> l<- [take n t] >>>> Control.Monad.guard (length l == n) >>>> return l >>>> >>>> and tried to use the ">>=" operator in order >>>> to figure out how Monads work. I came up with: >>>> >>>> test l = >>>> (Data.List.tails l) >>>>>> = (\t -> [take 2 t]) >>>>>> = (\l -> if (length l == 2) then [l] else []) >>>> >>>> Questions: >>>> 1. How can I use Control.Monad.guard directly in "test l" >>> >>> test l = >>> (Data.List.tails l) >>>>> = \t -> [take 2 t] >>>>> = \l -> Control.Monad.guard (length l == 2) >>>>> return l >>> >>> The rule is that >>> >>> x<- foo >>> >>> desugars to >>> >>> foo>>= \x -> ... >>> >>> and >>> >>> blah >>> >>> desugars to >>> >>> blah>> ... >>> >> >> Ok, I was not aware of the >>. >> >>> One thing that might have been tripping you up is your extra >>> parentheses around the lambda expressions. If you have >>> >>>>> = (\l -> ...) >>>>> foo... >>> >>> the l does not scope over foo... so you cannot mention it. Instead >>> what you want is >>> >>>>> = \l -> ... >>>>> foo... >>> >>> so the lambda expression is actually \l -> ...>> foo..., that is, >>> it includes *everything* after the \l -> ... and not just the stuff on >>> that line. >>> >> >> Hmmm. Still cannot wrap my mind around this B-(. >> >> [[1],[2],[3]] >>= \l -> func1 l >>= \m -> func2 m >> >> \l will hold each of the 3 elements of initial list >> these are concatenated with the results of func1 >> results in a new list >> >> \m will have each element in the new list >> these are concatenated with the results of func2 >> results in a last list >> >> is equal to ? >> >> (([[1],[2],[3]] >>= \l -> func1 l) >>= \m -> func2 m) > > Yes, your description is correct, and yes, these are equal. (Although > the first is often more efficient.) They are required to be equal by > the monad laws. However, consider > > [[1],[2],[3]] >>= \l -> func1 l >>= \m -> func2 m l > > and > > (([[1],[2],[3]] >>= \l -> func1 l) >>= \m -> func2 m l) > > Notice that func2 now takes a second argument. There is not even a > question of whether these are equal: the second does not even compile, > because the final 'l' is not in scope. This is the point I was trying > to make. > > -Brent > > > > ------------------------------ > > Message: 2 > Date: Tue, 18 Oct 2011 07:04:35 -0400 > From: Brent Yorgey <byorgey(a)seas.upenn.edu> > Subject: Re: [Haskell-beginners] recursion and pattern matching > To: beginners(a)haskell.org > Message-ID: <20111018110435.GB1102(a)seas.upenn.edu> > Content-Type: text/plain; charset=iso-8859-1 > > On Tue, Oct 18, 2011 at 01:34:14AM -0700, Alia wrote: >> I have a question about what's the idiomatic way to walk a tree where there is also a requirement >> for pattern-matching to draw variables out of the Node 'container': >> >> >> >> <Test.hs> >> >> module Test >> >> where >> >> data Tree a b = EmptyTree | Node a b [Tree a b] >> ??????????? deriving (Show, Read, Eq)? >> ? >> t =? Node "goal" 1.0 [ >> ??????? Node "c1" 0.5 [ >> ??????????? Node "c3" 3.0 [ >> ??????????????? Node "c5" 1.0 [] >> ??????????????? ] >> ??????????? ], >> ??????? Node "c2" 0.5 [ >> ??????????? Node "c4" 2.0 [] >> ??????????? ] >> ???? ] >> >> >> sumTree :: (Num b) => Tree a b -> b >> sumTree EmptyTree = 0 >> sumTree (Node _ value []) = value >> sumTree (Node _ value [x]) = value + sumTree x >> sumTree (Node name value (x:xs)) = value + sumTree x + sumTree (Node name 0 xs) >> >> depth :: Tree a b -> Int >> depth EmptyTree = 0 >> depth (Node _ _ []) = 1 >> depth (Node _ _ [x]) = 1 + depth x >> depth (Node n v (x:xs)) = 1 + depth (Node n v xs)? >> >> </Test.hs> >> >> Interactively: >> >> *Test> sumTree t >> 8.0 >> *Test> depth t >> 4 >> *Test> >> >> >> This seems to work, but I have a sense that one should use folds and fmap and that there >> is a better and cleaner what to do this. > > Your sense is absolutely right! =) You are not taking advantage of > the fact that [] is a functor and can be folded over, etc. -- you have > essentially hardcoded a list fold into your sumTree and depth > functions. First let's rewrite sumTree. We use 'map' to call > 'sumTree' recursively on all the child trees, then sum the results: > > sumTree :: (Num b) => Tree a b -> b > sumTree EmptyTree = 0 > sumTree (Node _ value children) = value + sum (map sumTree children) > > Tada! We handled all those list cases (empty, single element, or > cons) at once, in a general way. > > By the way, your implementation of 'depth' seems to be wrong: it only > cares about the depth of the last child. I would think the idea would > be to take the maximum depth of all the children and add one to that. > > I leave the rest for you: > > (1) rewrite depth in a similar way to sumTree, being sure to find > the maximum depth of all the children > > (2) generalize both sumTree and depth to a treeFold function: > > treeFold :: c -> (a -> b -> [c] -> c) -> Tree a b -> c > > The first argument says what to do with EmptyTree, and the > second argument says what to do with a Node. > > Once you have implemented treeFold you should be able to implement > both sumTree and depth in terms of treeFold. > > Hope this helps. Let us know if you get stuck or have more questions! > > -Brent > > > > ------------------------------ > > Message: 3 > Date: Tue, 18 Oct 2011 13:07:57 +0100 > From: Hugo Ferreira <hmf(a)inescporto.pt> > Subject: Re: [Haskell-beginners] newbie: Monad, equivalent notation > using Control.Monad.guard > To: Brent Yorgey <byorgey(a)seas.upenn.edu> > Cc: beginners(a)haskell.org > Message-ID: <4E9D6C1D.7020409(a)inescporto.pt> > Content-Type: text/plain; charset=ISO-8859-1; format=flowed > > On 10/18/2011 11:52 AM, Brent Yorgey wrote: >> On Tue, Oct 18, 2011 at 10:52:57AM +0100, Hugo Ferreira wrote: >>> Hello, >>> >>> On 10/17/2011 05:22 PM, Brent Yorgey wrote: >>>> On Mon, Oct 17, 2011 at 04:18:05PM +0100, Hugo Ferreira wrote: >>>>> Hello, >>>>> >>>>> I came across the following code: >>>>> >>>>> ngrams'' :: Int -> [a] -> [[a]] >>>>> ngrams'' n l = do >>>>> t<- Data.List.tails l >>>>> l<- [take n t] >>>>> Control.Monad.guard (length l == n) >>>>> return l >>>>> >>>>> and tried to use the ">>=" operator in order >>>>> to figure out how Monads work. I came up with: >>>>> >>>>> test l = >>>>> (Data.List.tails l) >>>>>>> = (\t -> [take 2 t]) >>>>>>> = (\l -> if (length l == 2) then [l] else []) >>>>> >>>>> Questions: >>>>> 1. How can I use Control.Monad.guard directly in "test l" >>>> >>>> test l = >>>> (Data.List.tails l) >>>>>> = \t -> [take 2 t] >>>>>> = \l -> Control.Monad.guard (length l == 2) >>>>>> return l >>>> >>>> The rule is that >>>> >>>> x<- foo >>>> >>>> desugars to >>>> >>>> foo>>= \x -> ... >>>> >>>> and >>>> >>>> blah >>>> >>>> desugars to >>>> >>>> blah>> ... >>>> >>> >>> Ok, I was not aware of the>>. >>> >>>> One thing that might have been tripping you up is your extra >>>> parentheses around the lambda expressions. If you have >>>> >>>>>> = (\l -> ...) >>>>>> foo... >>>> >>>> the l does not scope over foo... so you cannot mention it. Instead >>>> what you want is >>>> >>>>>> = \l -> ... >>>>>> foo... >>>> >>>> so the lambda expression is actually \l -> ...>> foo..., that is, >>>> it includes *everything* after the \l -> ... and not just the stuff on >>>> that line. >>>> >>> >>> Hmmm. Still cannot wrap my mind around this B-(. >>> >>> [[1],[2],[3]]>>= \l -> func1 l>>= \m -> func2 m >>> >>> \l will hold each of the 3 elements of initial list >>> these are concatenated with the results of func1 >>> results in a new list >>> >>> \m will have each element in the new list >>> these are concatenated with the results of func2 >>> results in a last list >>> >>> is equal to ? >>> >>> (([[1],[2],[3]]>>= \l -> func1 l)>>= \m -> func2 m) >> >> Yes, your description is correct, and yes, these are equal. (Although >> the first is often more efficient.) They are required to be equal by >> the monad laws. However, consider >> >> [[1],[2],[3]]>>= \l -> func1 l>>= \m -> func2 m l >> >> and >> >> (([[1],[2],[3]]>>= \l -> func1 l)>>= \m -> func2 m l) >> >> Notice that func2 now takes a second argument. There is not even a >> question of whether these are equal: the second does not even compile, >> because the final 'l' is not in scope. This is the point I was trying >> to make. > > Aaaah. Got it. > > Thanks, > Hugo F. > >> >> -Brent >> >> _______________________________________________ >> Beginners mailing list >> Beginners(a)haskell.org >> http://www.haskell.org/mailman/listinfo/beginners >> > > > > > ------------------------------ > > Message: 4 > Date: Tue, 18 Oct 2011 14:19:49 +0200 > From: Alexander Raasch <info(a)alexraasch.de> > Subject: [Haskell-beginners] Weird (++) behavior when adding 2 vectors > To: beginners(a)haskell.org > Message-ID: <4E9D6EE5.6090207(a)alexraasch.de> > Content-Type: text/plain; charset=ISO-8859-1; format=flowed > > Hi, > > so I wrote this function to add two vectors represented as lists: > > add a b = add' a b [] where > add' [] [] s = s > add' (a:as) (b:bs) s ++ [a+b] > > OK, I tried this in ghci: > >> add [1,2,3] [1,2,3] > [6,4,2] > > Hm, I expected the result to be [2,4,6], of course, since the currently > added components always go to the end of the resulting vector. I then > changed the last term in add' to > > [a+b] ++ s , > > but still > >> add [1,2,3] [1,2,3] > [6,4,2] > > Can anyone explain this behavior to me. I think there should be some > change in the result, no? > > Alex > > > > ------------------------------ > > Message: 5 > Date: Tue, 18 Oct 2011 14:36:40 +0200 > From: Vlad Hanciuta <wladsh(a)gmail.com> > Subject: Re: [Haskell-beginners] Weird (++) behavior when adding 2 > vectors > To: Alexander Raasch <info(a)alexraasch.de> > Cc: beginners(a)haskell.org > Message-ID: <7C0687B5-7061-41E4-900C-FA0F1301B53C(a)gmail.com> > Content-Type: text/plain; charset=us-ascii > > Hi, > > Your code is not valid syntactically, I guess the last equation for add' is "add' (a:as) (b:bs) s = add' as bs s ++ [a+b]". In that case, the function application binds stronger that ++ operator so the expression is actually equivalent to "(add' as bs s) ++ [a+b]". So you can easily see that the list is computed backwards. > > Vlad > > On 18 Oct 2011, at 14:19, Alexander Raasch wrote: > >> Hi, >> >> so I wrote this function to add two vectors represented as lists: >> >> add a b = add' a b [] where >> add' [] [] s = s >> add' (a:as) (b:bs) s ++ [a+b] >> >> OK, I tried this in ghci: >> >>> add [1,2,3] [1,2,3] >> [6,4,2] >> >> Hm, I expected the result to be [2,4,6], of course, since the currently added components always go to the end of the resulting vector. I then changed the last term in add' to >> >> [a+b] ++ s , >> >> but still >> >>> add [1,2,3] [1,2,3] >> [6,4,2] >> >> Can anyone explain this behavior to me. I think there should be some change in the result, no? >> >> Alex >> >> _______________________________________________ >> Beginners mailing list >> Beginners(a)haskell.org >> http://www.haskell.org/mailman/listinfo/beginners > > > > > ------------------------------ > > Message: 6 > Date: Tue, 18 Oct 2011 13:48:40 +0100 > From: Lorenzo Bolla <lbolla(a)gmail.com> > Subject: Re: [Haskell-beginners] Weird (++) behavior when adding 2 > vectors > To: Alexander Raasch <info(a)alexraasch.de> > Cc: beginners(a)haskell.org > Message-ID: > <CADjgTRzTafiyMwFuNd8UYyMw7Djxvf-7SNespN8W5hKSm7mhUA(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Hi, > > On Tue, Oct 18, 2011 at 1:19 PM, Alexander Raasch <info(a)alexraasch.de>wrote: > >> Hi, >> >> so I wrote this function to add two vectors represented as lists: >> >> add a b = add' a b [] where >> add' [] [] s = s >> add' (a:as) (b:bs) s ++ [a+b] >> >> > I think something mangled your function, as this is not valid Haskell code. > > Anyway, I tried to rewrite your function. > The first version works as expected; the second gives reversed output. > Note that there is no need for the accumulator "s". > > add a b = add' a b > where add' [] [] = [] > add' (a:as) (b:bs) = [a+b] ++ (add' as bs) > > add a b = add' a b > where add' [] [] = [] > add' (a:as) (b:bs) = (add' as bs) ++ [a+b] -- reversed output > > Obviously, the same function can be written as: > zipWith (+) [1,2,3] [1,2,3] > > hth, > L. >

1 0

Re: [Haskell-beginners] recursion and pattern matching
by Alia 18 Oct '11

18 Oct '11

<snip Brent Yorgey's helpful advice> I'm afraid my powers of abstraction are failing me, I managed to get the depth function ok and along the way accidentally made a count (nodes) function: sumTree :: (Num b) => Tree a b -> b sumTree EmptyTree = 0 sumTree (Node _ value children) = value + sum (map sumTree children) count :: Tree a b -> Int count EmptyTree = 0 count (Node _ value children) = 1 + sum (map count children) depth :: Tree a b -> Int depth EmptyTree = 0 depth (Node _ value []) = 1 depth (Node _ value children) = 1 + maximum (map depth children) However, I'm stuck on the treeFold function given your function signature: treeFold :: c -> (a -> b -> [c] -> c) -> Tree a b -> c At first I read it as c is an output type and also the type of the accumulator, which addresses the EmptyTree scenario: treeFold acc f EmptyTree = acc So far so good. Now, the 2nd arg which is a function specification, takes an a and b (for the name and value respectively) and a list of cs. Now this is confusing to me because the value of b is actually desirable as an output type as well. Did you mean c to refer to a list of children. If so then why didn't you write the func spec as: treeFold :: b -> (a -> b -> [Tree a b] -> b) -> Tree a b -> b Sorry to be so dense about this, but I wanted to clarify this issue before I ran off and started looking at Data.Monoid and Data.Foldable from Learn me a haskell (-: AK

2 3

Weird (++) behavior when adding 2 vectors
by Alexander Raasch 18 Oct '11

18 Oct '11

Hi, so I wrote this function to add two vectors represented as lists: add a b = add' a b [] where add' [] [] s = s add' (a:as) (b:bs) s ++ [a+b] OK, I tried this in ghci: > add [1,2,3] [1,2,3] [6,4,2] Hm, I expected the result to be [2,4,6], of course, since the currently added components always go to the end of the resulting vector. I then changed the last term in add' to [a+b] ++ s , but still > add [1,2,3] [1,2,3] [6,4,2] Can anyone explain this behavior to me. I think there should be some change in the result, no? Alex

4 4

newbie: Monad, equivalent notation using Control.Monad.guard
by Hugo Ferreira 18 Oct '11

18 Oct '11

Hello, I came across the following code: ngrams'' :: Int -> [a] -> [[a]] ngrams'' n l = do t <- Data.List.tails l l <- [take n t] Control.Monad.guard (length l == n) return l and tried to use the ">>=" operator in order to figure out how Monads work. I came up with: test l = (Data.List.tails l) >>= (\t -> [take 2 t]) >>= (\l -> if (length l == 2) then [l] else []) Questions: 1. How can I use Control.Monad.guard directly in "test l" 2. Related issue: how can create a List monad so that I can input "l" argument of "test l" directly? TIA, Hugo F.

2 4

recursion and pattern matching
by Alia 18 Oct '11

18 Oct '11

I have a question about what's the idiomatic way to walk a tree where there is also a requirement for pattern-matching to draw variables out of the Node 'container': <Test.hs> module Test where data Tree a b = EmptyTree | Node a b [Tree a b] deriving (Show, Read, Eq) t = Node "goal" 1.0 [ Node "c1" 0.5 [ Node "c3" 3.0 [ Node "c5" 1.0 [] ] ], Node "c2" 0.5 [ Node "c4" 2.0 [] ] ] sumTree :: (Num b) => Tree a b -> b sumTree EmptyTree = 0 sumTree (Node _ value []) = value sumTree (Node _ value [x]) = value + sumTree x sumTree (Node name value (x:xs)) = value + sumTree x + sumTree (Node name 0 xs) depth :: Tree a b -> Int depth EmptyTree = 0 depth (Node _ _ []) = 1 depth (Node _ _ [x]) = 1 + depth x depth (Node n v (x:xs)) = 1 + depth (Node n v xs) </Test.hs> Interactively: *Test> sumTree t 8.0 *Test> depth t 4 *Test> This seems to work, but I have a sense that one should use folds and fmap and that there is a better and cleaner what to do this. Any help would be much appreciated. Thanks AK

2 1

Non exhaustive pattern match not flagged?
by Hugo Ferreira 18 Oct '11

18 Oct '11

Hello, I am using the GHC compiler with the -W flag. When I compile: f :: [a] -> [b] -> Int --f [] _ = error "undefined for empty array" f _ [] = error "undefined for empty array" f (_:xs) (_:ys) = length xs + length ys I get a warning: Warning: Pattern match(es) are non-exhaustive In an equation for `f': Patterns not matched: [] (_ : _) as expected. But for: bigrams :: [a] -> [[a]] --bigrams [] = [] bigrams [_] = [] bigrams xs = take 2 xs : bigrams (tail xs) I don't. Why is the first predicate not detected as missing? TIA, Hugo F.

2 2