Send Beginners mailing list submissions to
beginners@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-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. Type explanation of foldl? (Lawrence Bottorff)
2. Re: Type explanation of foldl? (David James)
----------------------------------------------------------------------
Message: 1
Date: Sat, 2 Jan 2021 11:51:57 -0600
From: Lawrence Bottorff <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: [Haskell-beginners] Type explanation of foldl?
Message-ID:
<CAFAhFSVFGRMn2=_sv0w1jl95mgxtatujj866zmnf4fghc-k...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
I've got this
myFoldl f init [] = init
myFoldl f init (x:xs) = myFoldl f newInit xs
where newInit = f init x
which when evaluated gives this for its type
> :t myFoldl
myFoldl :: (t -> a -> t) -> t -> [a] -> t
. . . not totally sure what that all means, e.g., how the t as a generic
class is behaving is very mysterious. Obviously, the final result is of
type t . . . and that must relate to the incoming argument init, correct?
(BTW, does a type declaration like this one reflect in any way the
recursion going on?) But then with Prelude foldl I'm really clueless
> :t foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
I'm guessing the t is again a generic type of the Foldable class, but then.
. . Can someone walk me through this?
LB
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210102/5efcd099/attachment-0001.html>
------------------------------
Message: 2
Date: Sun, 3 Jan 2021 10:31:44 +0000
From: David James <dj112...@outlook.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Type explanation of foldl?
Message-ID:
<am6pr04mb42148d13c8c94798945fd348b6...@am6pr04mb4214.eurprd04.prod.outlook.com>
Content-Type: text/plain; charset="windows-1252"
Hello – in
myFoldl :: (t -> a -> t) -> t -> [a] -> t
the t and the a are type variables. There are no “classes” at all. Since you
didn’t name the type variables, Haskell has provided default names for you “at
random”, and it’s in some ways a little unfortunate that it’s named one of them
t.
You could (probably should) provide your own declaration, e.g. renaming t to b:
myFoldl :: (b -> a -> b) -> b -> [a] -> b
This represents exactly the same thing, and says that myFoldl will work for any
two types a and b. It takes three params:
(b -> a -> b) A function of values of type b and type a
that returns a value of type b. (The
accumulation function)
b A value of type b
(The initial accumulated value)
[a] A list of values of type a
(This list to accumulate over)
and returns
b A value of type b
(The final accumulated value)
The prelude function:
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
is then almost identical. This time, though, instead of being restricted to a
list of values (of type a) to fold over, it can fold over any type of foldable
collection of values (of type a). t represents the type of the foldable
collection, and Foldable t => is a constraint that says the function will only
work for a type t that is an instance of the class Foldable.
[BTW: does a type declaration like this one reflect in any way the recursion
going on? I didn’t really understand the question, but you can often deduce
what a function does, and how it might be implemented, from its type signature.]
I don’t know how you’re going about learning Haskell, but following a tutorial
(such as http://learnyouahaskell.com/) might be helpful, and I think explains
all of the above step by step.
Regards, David.
From: Lawrence Bottorff<mailto:borg...@gmail.com>
Sent: 02 January 2021 17:52
To: The Haskell-Beginners Mailing List - Discussion of primarily beginner-level
topics related to Haskell<mailto:beginners@haskell.org>
Subject: [Haskell-beginners] Type explanation of foldl?
I've got this
myFoldl f init [] = init
myFoldl f init (x:xs) = myFoldl f newInit xs
where newInit = f init x
which when evaluated gives this for its type
> :t myFoldl
myFoldl :: (t -> a -> t) -> t -> [a] -> t
. . . not totally sure what that all means, e.g., how the t as a generic class
is behaving is very mysterious. Obviously, the final result is of type t . . .
and that must relate to the incoming argument init, correct? (BTW, does a type
declaration like this one reflect in any way the recursion going on?) But then
with Prelude foldl I'm really clueless
> :t foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
I'm guessing the t is again a generic type of the Foldable class, but then. . .
Can someone walk me through this?
LB
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210103/278cd30a/attachment-0001.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 150, Issue 2
*****************************************
