# Beginners Digest, Vol 121, Issue 13

```Send Beginners mailing list submissions to

To subscribe or unsubscribe via the World Wide Web, visit
or, via email, send a message with subject or body 'help' to
```
You can reach the person managing the list at

than "Re: Contents of Beginners digest..."

Today's Topics:

1.  Two small questions from the section "Making a safe RPN
calculator" in LYAH (Olumide)
2. Re:  Two small questions from the section "Making a safe RPN
calculator" in LYAH (David McBride)
3.  The type class Read (mrx)
4. Re:  The type class Read (PY)
5. Re:  The type class Read (Francesco Ariis)

----------------------------------------------------------------------

Message: 1
Date: Wed, 11 Jul 2018 18:24:19 +0100
From: Olumide <50...@web.de>
To: The Haskell-Beginners Mailing List - Discussion of primarily
Subject: [Haskell-beginners] Two small questions from the section
"Making a safe RPN calculator" in LYAH
Message-ID: <d89b0202-bc66-85ca-e600-e6dba1821...@web.de>
Content-Type: text/plain; charset=utf-8; format=flowed

Dear List,

Question 1:
In the section "Making a safe RPN calculator" of LYAH (Chapter 14 --
there is an expression: read numberString:xs, take from the last line of
the function

foldingFunction :: [Double] -> String -> [Double]
foldingFunction (x:y:ys) "*" = (x * y):ys
foldingFunction (x:y:ys) "+" = (x + y):ys
foldingFunction (x:y:ys) "-" = (y - x):ys
foldingFunction xs numberString = read numberString:xs

My first question is why is the read function called before the cons
operator?

Question 2:
The same section of the book also introduces the reads function which is
used to implement the readMaybe function and a refactored foldingFunction

_ -> Nothing

foldingFunction :: [Double] -> String -> Maybe [Double]
foldingFunction (x:y:ys) "*" = return ((x * y):ys)
foldingFunction (x:y:ys) "+" = return ((x + y):ys)
foldingFunction (x:y:ys) "-" = return ((y - x):ys)
foldingFunction xs numberString = liftM (:xs) (readMaybe
numberString)

I'd like to know why the foldingFunction returns Nothing in the
following example:

ghci> foldingFunction [] "1 wawawawa"
Nothing

Considering that reads "1 wawawawa" does not return Nothing, as follows

ghci> reads "1 wawawawa" :: [(Double,String)]
[(1.0," wawawawa")]

Regards,

- Olumide

------------------------------

Message: 2
Date: Wed, 11 Jul 2018 13:30:51 -0400
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
Subject: Re: [Haskell-beginners] Two small questions from the section
"Making a safe RPN calculator" in LYAH
Message-ID:
<can+tr42bytuiyeliptgbca_mhcn+ynpeemqfvgdhe9eqigx...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

1)  Not entirely sure what you mean.  The expression is parsed as (read
numberString) : xs, which means that the result number is prepended to the
front of the list.

2) Because [(x,"")] does not match [(1.0," wawawawa")].  An empty string
does not match a string with characters in it.

On Wed, Jul 11, 2018 at 1:24 PM, Olumide <50...@web.de> wrote:

> Dear List,
>
> Question 1:
> In the section "Making a safe RPN calculator" of LYAH (Chapter 14 --
> there is an expression: read numberString:xs, take from the last line of
> the function
>
>     foldingFunction :: [Double] -> String -> [Double]
>     foldingFunction (x:y:ys) "*" = (x * y):ys
>     foldingFunction (x:y:ys) "+" = (x + y):ys
>     foldingFunction (x:y:ys) "-" = (y - x):ys
>     foldingFunction xs numberString = read numberString:xs
>
> My first question is why is the read function called before the cons
> operator?
>
> Question 2:
> The same section of the book also introduces the reads function which is
> used to implement the readMaybe function and a refactored foldingFunction
>
>     readMaybe st = case reads st of [(x,"")] -> Just x
>                                     _ -> Nothing
>
>     foldingFunction :: [Double] -> String -> Maybe [Double]
>     foldingFunction (x:y:ys) "*" = return ((x * y):ys)
>     foldingFunction (x:y:ys) "+" = return ((x + y):ys)
>     foldingFunction (x:y:ys) "-" = return ((y - x):ys)
>     foldingFunction xs numberString = liftM (:xs) (readMaybe numberString)
>
> I'd like to know why the foldingFunction returns Nothing in the following
> example:
>
> ghci> foldingFunction [] "1 wawawawa"
> Nothing
>
> Considering that reads "1 wawawawa" does not return Nothing, as follows
>
> ghci> reads "1 wawawawa" :: [(Double,String)]
> [(1.0," wawawawa")]
>
> Regards,
>
> - Olumide
>
> _______________________________________________
> Beginners mailing list
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:

------------------------------

Message: 3
Date: Thu, 12 Jul 2018 12:05:52 +0200
From: mrx <patrik....@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
Message-ID:
<CANzOjBicRt1z9KyaFcwmy_0Wr=hd5CFNHLE1Eh=rsfgafhb...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

Hi,

I'm trying to make sense of the type class `Read`. It feels to be like a
function performing casting to me, similar to what you have in C and Java.

The weird thing is that the casting doesn't have to make sense, type-wise.
So `read "5" :: Int` produce the integer 5 which make sense but `read
"(3,'a')" :: Int` doesn't make sense to me but ghci accepts it!

This is seeing Read as a function, as it's a type class i suspect I'm
missing something. Quite possibly quite a lot...

Why is the type class called `Read`?
What am I missing above?

// Patrik Iselind
-------------- next part --------------
An HTML attachment was scrubbed...
URL:

------------------------------

Message: 4
Date: Thu, 12 Jul 2018 14:08:29 +0300
From: PY <aqua...@gmail.com>
Message-ID: <e4517791-c30b-0908-2e29-12af807f9...@gmail.com>
Content-Type: text/plain; charset="utf-8"; Format="flowed"

read "(3,'a')"::(Int, Char)  returns expected tuple. But with ":: Int"
leads to runtime exception, because it calls `readsPrec` of Int and can
not parse such string. But readsPrec of (a,b) where both are readable
parses it successfully.

12.07.2018 13:05, mrx wrote:
> Hi,
>
> I'm trying to make sense of the type class `Read`. It feels to be like
> a function performing casting to me, similar to what you have in C and
> Java.
>
> The weird thing is that the casting doesn't have to make sense,
> type-wise. So `read "5" :: Int` produce the integer 5 which make sense
> but `read "(3,'a')" :: Int` doesn't make sense to me but ghci accepts it!
>
> This is seeing Read as a function, as it's a type class i suspect I'm
> missing something. Quite possibly quite a lot...
>
> Why is the type class called `Read`?
> What am I missing above?
>
> // Patrik Iselind
>
>
> _______________________________________________
> Beginners mailing list

-------------- next part --------------
An HTML attachment was scrubbed...
URL:

------------------------------

Message: 5
Date: Thu, 12 Jul 2018 13:14:32 +0200
From: Francesco Ariis <fa...@ariis.it>
Message-ID: <20180712111432.ht3mrwj6x2gwt...@x60s.casa>
Content-Type: text/plain; charset=utf-8

Hello Patrik,

On Thu, Jul 12, 2018 at 12:05:52PM +0200, mrx wrote:
> Why is the type class called `Read`?
> What am I missing above?

we can say any instance of `Read` has to implement

-- the actual instance implements a different function,
-- but that's not relevant for our example

lower-case `r`).  The function goes from  `String` (and no other
things) to our implemented type.

As you discovered, the conversion happens at runtime, the compiler
has no way to check it beforehand, and things might explode during
execution

It is often a good idea to use `readMay` (from Safe) to handle
failures locally without throwing an exception

shoot again
-F

------------------------------

Subject: Digest Footer

_______________________________________________
Beginners mailing list