Re: [Haskell-beginners] Beginners Digest, Vol 40, Issue 27

18 Oct 2011


      please unsubscribe


On Oct 18, 2011, at 6:04 AM, beginners-request@haskell.org wrote:
...
Send Beginners mailing list submissions to
  beginners@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@haskell.org
You can reach the person managing the list at
  beginners-owner@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 
Subject: Re: [Haskell-beginners] newbie: Monad, equivalent notation
  using Control.Monad.guard
To: beginners@haskell.org
Message-ID: <20111018105201.GA1102@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 
Subject: Re: [Haskell-beginners] recursion and pattern matching
To: beginners@haskell.org
Message-ID: <20111018110435.GB1102@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':

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)?

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 
Subject: Re: [Haskell-beginners] newbie: Monad, equivalent notation
  using Control.Monad.guard
To: Brent Yorgey 
Cc: beginners@haskell.org
Message-ID: <4E9D6C1D.7020409@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@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 4
Date: Tue, 18 Oct 2011 14:19:49 +0200
From: Alexander Raasch 
Subject: [Haskell-beginners] Weird (++) behavior when adding 2 vectors
To: beginners@haskell.org
Message-ID: <4E9D6EE5.6090207@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 
Subject: Re: [Haskell-beginners] Weird (++) behavior when adding 2
  vectors
To: Alexander Raasch 
Cc: beginners@haskell.org
Message-ID: <7C0687B5-7061-41E4-900C-FA0F1301B53C@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@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 6
Date: Tue, 18 Oct 2011 13:48:40 +0100
From: Lorenzo Bolla 
Subject: Re: [Haskell-beginners] Weird (++) behavior when adding 2
  vectors
To: Alexander Raasch 
Cc: beginners@haskell.org
Message-ID:
  
Content-Type: text/plain; charset="utf-8"
Hi,
On Tue, Oct 18, 2011 at 1:19 PM, 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]
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.

Re: [Haskell-beginners] Beginners Digest, Vol 40, Issue 27

Bob Walters-LT