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-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@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: folds again -- myCycle (7stud)
2. Re: Re: folds again -- myCycle (Daniel Fischer)
3. Innovating control structures (Girish Bhat)
4. Re: Innovating control structures (Girish Bhat)
5. Re: folds again -- myCycle (7stud)
6. infix functions with 3 args (7stud)
7. Re: infix functions with 3 args (Thomas Davie)
8. Problems when trying to solve yaht exercise 3.10 (ZelluX)
----------------------------------------------------------------------
Message: 1
Date: Thu, 19 Mar 2009 19:32:19 +0000 (UTC)
From: 7stud <bbxx789_0...@yahoo.com>
Subject: [Haskell-beginners] Re: folds again -- myCycle
To: beginners@haskell.org
Message-ID: <loom.20090319t190853-...@post.gmane.org>
Content-Type: text/plain; charset=us-ascii
Will Ness <will_n48 <at> yahoo.com> writes:
> In our case, having
> The access in (head ys) gets traslated in
>
> head ys = head (ys ++ [1,2,3]) = head ((ys ++ [1,2,3]) ++ [1,2,3])
>
> but for the other defintion
>
> let zs = [1, 2, 3] ++ zs
>
> it's
>
> head zs = head([1, 2, 3] ++ zs) = head( (1:[2,3]) ++ zs)
> = head( 1:([2,3]++zs) ) = 1
>
> according to the defintion of (++),
>
> (x:xs)++ys = x:(xs++ys)
>
> Were we to use the foldr definition, it'll get rewritten just the same, using
> the foldr definition (as long as it's not the left-recursive defintion):
>
> foldr f z (a:as) = a `f` foldr f z as
>
> let ws = foldr (:) [1,2,3] ws
>
> head ws = head (foldr (:) [1,2,3] ws)
> = head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
>
> because 'ws' is getting matched against (a:as) pattern in foldr definition,
> so
> is immediately needed, causing INFINITE looping. BUT
>
I'm confused by your statement that ws is getting matched against the
(a:as) pattern in the foldr definition, and therefore it is immediately
evaluated. I didn't think the let expression:
> let ws = foldr (:) [1,2,3] ws
would cause infinite looping.
Wouldn't it be the head pattern that is being matched, and therefore head
triggers the evaluation? Although, I'm not seeing a pattern match here:
>head (x:xs) = x
>head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
..
...
...
..
..
,,,
...
....
------------------------------
Message: 2
Date: Thu, 19 Mar 2009 21:01:30 +0100
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] Re: folds again -- myCycle
To: 7stud <bbxx789_0...@yahoo.com>, beginners@haskell.org
Message-ID: <200903192101.30673.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="iso-8859-1"
Am Donnerstag, 19. März 2009 20:32 schrieb 7stud:
> Will Ness <will_n48 <at> yahoo.com> writes:
> > In our case, having
> > The access in (head ys) gets traslated in
> >
> > head ys = head (ys ++ [1,2,3]) = head ((ys ++ [1,2,3]) ++ [1,2,3])
> >
> > but for the other defintion
> >
> > let zs = [1, 2, 3] ++ zs
> >
> > it's
> >
> > head zs = head([1, 2, 3] ++ zs) = head( (1:[2,3]) ++ zs)
> > = head( 1:([2,3]++zs) ) = 1
> >
> > according to the defintion of (++),
> >
> > (x:xs)++ys = x:(xs++ys)
> >
> > Were we to use the foldr definition, it'll get rewritten just the same,
> > using the foldr definition (as long as it's not the left-recursive
> > defintion):
> >
> > foldr f z (a:as) = a `f` foldr f z as
> >
> > let ws = foldr (:) [1,2,3] ws
> >
> > head ws = head (foldr (:) [1,2,3] ws)
> > = head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
> >
> > because 'ws' is getting matched against (a:as) pattern in foldr
> > definition, so is immediately needed, causing INFINITE looping. BUT
>
> I'm confused by your statement that ws is getting matched against the
> (a:as) pattern in the foldr definition, and therefore it is immediately
>
> evaluated. I didn't think the let expression:
> > let ws = foldr (:) [1,2,3] ws
>
> would cause infinite looping.
Note this is again the left recursive bad definition. As long as we don't want
to know anything about ws, the definition
ws = foldr (:) [1,2,3] ws
sleeps peacefully.
>
> Wouldn't it be the head pattern that is being matched, and therefore head
>
> triggers the evaluation?
If we need to know about the structure of ws, for example if we query
head ws
the evaluation of ws is triggered. In the case of head, we want to know if ws
matches the pattern (_:_), in which case head returns the head of ws, or not,
in which case head throws an exception.
So the implementation tries to match ws with the pattern (_:_). To see if it
matches, it must evaluate ws, first replacing ws by the right hand side of
its definition, foldr (:) [1,2,3] ws. Doesn't yet say if ws matches (_:_), so
the foldr must be evaluated.
foldr (:) [1,2,3] [] ~> [1,2,3]
foldr (:) [1,2,3] (y:ys) = y:foldr (:) [1,2,3] ys
To know which equation to use, the implementation tries to match ws with [].
Unfortunately, there is no information about the structure of ws available
yet. So ws is replaced by the right hand side of its definition to find out
whether it matches [], leading to
head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws)).
Dang, to see whether the inner foldr returns an empty list or not, we need to
know whether ws is empty or not, so we must replace ws in the inner foldr
with the right hand side of its definition...
> Although, I'm not seeing a pattern match here:
> >head (x:xs) = x
^^^^^^ the pattern
> >head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
the expression which is matched against the pattern
------------------------------
Message: 3
Date: Fri, 20 Mar 2009 02:33:43 +0530
From: Girish Bhat <girishbhat6...@gmail.com>
Subject: [Haskell-beginners] Innovating control structures
To: beginners@haskell.org
Message-ID:
<cdef83d60903191403h7a57ba96wd1aa63007d742...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Ok, I keep hearing about functional programming allowing you to
innovate control structures and certainly monads have a role to play
there.
I was wondering if you guys would point me to particularly elegant or
pleasing idioms.
For example, I seem to be pleased to be re-acquainted with the
recursive for loop :)
------------------------------
Message: 4
Date: Fri, 20 Mar 2009 12:59:28 +0530
From: Girish Bhat <girishbhat6...@gmail.com>
Subject: [Haskell-beginners] Re: Innovating control structures
To: beginners@haskell.org
Message-ID:
<cdef83d60903200029k40f428b8u8dcdc3b3ecda1...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Ok, I just got a bit panaroid that I didn't specify that I do know
about fold, map etc :)
On 3/20/09, Girish Bhat <girishbhat6...@gmail.com> wrote:
> Ok, I keep hearing about functional programming allowing you to
> innovate control structures and certainly monads have a role to play
> there.
> I was wondering if you guys would point me to particularly elegant or
> pleasing idioms.
>
> For example, I seem to be pleased to be re-acquainted with the
> recursive for loop :)
>
------------------------------
Message: 5
Date: Fri, 20 Mar 2009 08:21:07 +0000 (UTC)
From: 7stud <bbxx789_0...@yahoo.com>
Subject: [Haskell-beginners] Re: folds again -- myCycle
To: beginners@haskell.org
Message-ID: <loom.20090320t080001-...@post.gmane.org>
Content-Type: text/plain; charset=utf-8
Daniel Fischer <daniel.is.fischer <at> web.de> writes:
> Am Donnerstag, 19. März 2009 20:32 schrieb 7stud:
> > Will Ness <will_n48 <at> yahoo.com> writes:
> > > let ws = foldr (:) [1,2,3] ws
> > >
> > > head ws = head (foldr (:) [1,2,3] ws)
> > > = head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
> > >
> > > because 'ws' is getting matched against (a:as) pattern in foldr
> > > definition, so is immediately needed, causing INFINITE looping. BUT
> >
> > I'm confused by your statement that ws is getting matched against the
> > (a:as) pattern in the foldr definition, and therefore it is immediately
> >
> > evaluated. I didn't think the let expression:
> > > let ws = foldr (:) [1,2,3] ws
> >
> > would cause infinite looping.
>
> Note this is again the left recursive bad definition. As long as we don't
> want
> to know anything about ws, the definition
>
> ws = foldr (:) [1,2,3] ws
>
> sleeps peacefully.
>
Check...................................................
..............................................................
............................................................
.............................................................
> > Wouldn't it be the head pattern that is being matched, and therefore head
> >
> > triggers the evaluation?
>
> If we need to know about the structure of ws, for example if we query
>
> head ws
>
> the evaluation of ws is triggered. In the case of head, we want to know if ws
> matches the pattern (_:_), in which case head returns the head of ws, or not,
> in which case head throws an exception.
>
> So the implementation tries to match ws with the pattern (_:_). To see if it
> matches, it must evaluate ws, first replacing ws by the right hand side of
> its definition, foldr (:) [1,2,3] ws. Doesn't yet say if ws matches (_:_), so
> the foldr must be evaluated.
.........................
.........................
.........................
.........................
.........................
foldr _ zero [] = zero (from def of foldr)
> foldr (:) [1,2,3] [] ~> [1,2,3]
> foldr (:) [1,2,3] (y:ys) = y : foldr (:) [1,2,3] ys
= (:) y (foldr (:) [1,2,3] ys)
foldr step zero (x:xs) = step x (foldr step zero xs)
(from definition of foldr)
...........................
...........................
..........................
..........................
> To know which equation to use, the implementation tries to match ws with [].
> Unfortunately, there is no information about the structure of ws available
> yet. So ws is replaced by the right hand side of its definition to find out
> whether it matches [], leading to
>
> head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws)).
>
> Dang, to see whether the inner foldr returns an empty list or not
??
I think you meant to say something like, "to see whether ws is an empty
list and therefore foldr returns [1, 2, 3]:
foldr (:) [1,2,3] ws
> foldr (:) [1,2,3] [] = [1,2,3]
we need to know whether ws is empty or not."
> so we must replace ws in the inner foldr
> with the right hand side of its definition...
>
> > Although, I'm not seeing a pattern match here:
> > >head (x:xs) = x
> ^^^^^^ the pattern
> > >head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> the expression which is *trying*(?) to be matched against the pattern
>
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
....
...
...
...
...
------------------------------
Message: 6
Date: Fri, 20 Mar 2009 11:05:49 +0000 (UTC)
From: 7stud <bbxx789_0...@yahoo.com>
Subject: [Haskell-beginners] infix functions with 3 args
To: beginners@haskell.org
Message-ID: <loom.20090320t105633-...@post.gmane.org>
Content-Type: text/plain; charset=us-ascii
On p. 76 of RWH, it says:
"If a function or constructor takes two or more arguments, we have
the option of using it in infix
form, where we place it between its first and second arguments."
Here is my code:
func2 x y = x + y
func3 x y z = x + y + z
Here are the results:
*Main> func2 10 20
30
*Main> 10 `func2` 20
30
*Main> func3 10 20 30
60
*Main> 10 `func3` 20 30
<interactive>:1:11:
No instance for (Num (t1 -> t))
arising from the literal `20' at <interactive>:1:11-15
Possible fix: add an instance declaration for (Num (t1 -> t))
In the second argument of `func3', namely `20 30'
In the expression: 10 `func3` 20 30
In the definition of `it': it = 10 `func3` 20 30
How do you get a function to work using infix notation when it has
3 arguments?
------------------------------
Message: 7
Date: Fri, 20 Mar 2009 12:07:52 +0100
From: Thomas Davie <tom.da...@gmail.com>
Subject: Re: [Haskell-beginners] infix functions with 3 args
To: 7stud <bbxx789_0...@yahoo.com>
Cc: beginners@haskell.org
Message-ID: <5dfe0a56-c8ff-4d6b-9f1a-0fc807024...@gmail.com>
Content-Type: text/plain; charset=US-ASCII; format=flowed
On 20 Mar 2009, at 12:05, 7stud wrote:
> On p. 76 of RWH, it says:
>
> "If a function or constructor takes two or more arguments, we have
> the option of using it in infix
> form, where we place it between its first and second arguments."
>
> Here is my code:
>
> func2 x y = x + y
>
> func3 x y z = x + y + z
>
> Here are the results:
>
> *Main> func2 10 20
> 30
> *Main> 10 `func2` 20
> 30
> *Main> func3 10 20 30
> 60
> *Main> 10 `func3` 20 30
>
> <interactive>:1:11:
> No instance for (Num (t1 -> t))
> arising from the literal `20' at <interactive>:1:11-15
> Possible fix: add an instance declaration for (Num (t1 -> t))
> In the second argument of `func3', namely `20 30'
> In the expression: 10 `func3` 20 30
> In the definition of `it': it = 10 `func3` 20 30
>
> How do you get a function to work using infix notation when it has
> 3 arguments?
Prelude> (10 `func3` 20) 30
60
Bob
------------------------------
Message: 8
Date: Fri, 20 Mar 2009 20:45:35 +0800
From: ZelluX <zel...@gmail.com>
Subject: [Haskell-beginners] Problems when trying to solve yaht
exercise 3.10
To: beginners@haskell.org
Message-ID:
<e487823f0903200545k70d13d20ib85d85a5d9ee6...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Hi, all
I'm new to haskell and currently reading yaht. I find some problems when
trying to solve exercise 3.10.
The exersices asks to read a list of numbers terminated by a zero, and
figure out the sum and product of the list. My program is as follows:
ex3_10 = do
hSetBuffering stdin LineBuffering
numbers <- getNumber
let sum = foldr (+) 0 numbers
product = foldr (*) 1 numbers
putStrLn "The sum is " ++ show(sum)
putStrLn "The product is " ++ show(product)
getNumber = do
putStrLn "Give me a number (or 0 to stop):"
num <- getLine
if read num == 0
then return []
else do
rest <- getNumber
return (read num : rest)
But when i load the program, ghci reports error:
Couldn't match expected type `[a]' against inferred type `IO ()'
In the first argument of `(++)', namely `putStrLn "The sum is "'
In a stmt of a 'do' expression:
putStrLn "The sum is " ++ show (sum)
And i just don't understand the first sentence. Could you tell what does it
mean?
Thanks for your reply
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20090320/1ee32429/attachment.htm
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 9, Issue 23
****************************************
