# Beginners Digest, Vol 99, Issue 15

```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. Re:  Beginners Digest, Vol 99, Issue 13 (Tushar Tyagi)

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

Message: 1
Date: Fri, 23 Sep 2016 09:01:18 +0530
From: Tushar Tyagi <tusha...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
Subject: Re: [Haskell-beginners] Beginners Digest, Vol 99, Issue 13
Message-ID:
<caedpzikcmlepiop-5bgbdakzk1tifau6ymf+jmjq_reumnn...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

In your implementation sumList and lengthList both return 'Num' which
doesn't define a division operator. So you have to convert them into
fractional by either changing the signatures of these 2 functions from Num
to Fractional, or use fromIntegral function, (or something else) . Two of
these approaches have been suggested by people here. :)

Typed using my phone, so excuse my brevity.

On 23 Sep 2016 6:14 a.m., "Lai Boon Hui" <laibo...@gmail.com> wrote:

> Hi All,
>
> i am overwhelmed by all the helpful responses. Thanks guys.
>
> I am more curious about why
>
> meanList :: (Num a, Fractional b) => [a] -> b
> meanList xs = (sumList xs) / (lengthList xs)
>
> does not compile.
>
> 'a' being a Num type seems perfectly fine, (/) returns a Fractional type
> hence 'b' being Fractional seems also fine.
>
>
>
> On Fri, Sep 23, 2016 at 7:13 AM, <beginners-requ...@haskell.org> wrote:
>
>> 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.  Newbie question about function type constraints (Lai Boon Hui)
>>    2. Re:  Newbie question about function type  constraints
>>       (Tushar Tyagi)
>>    3. Re:  Newbie question about function type  constraints
>>       (Imants Cekusins)
>>    4. Re:  Newbie question about function type constraints
>>       (Harald Bögeholz)
>>    5. Re:  Newbie question about function type constraints
>>       (Sylvain Henry)
>>    6. Re:  Newbie question about function type constraints
>>       (Sylvain Henry)
>>    7.  The meaning of categories constructed from HASK
>>       (Dimitri DeFigueiredo)
>>
>>
>> ----------------------------------------------------------------------
>>
>> Message: 1
>> Date: Thu, 22 Sep 2016 21:19:12 +0800
>> From: Lai Boon Hui <laibo...@gmail.com>
>>         constraints
>> Message-ID:
>>         <CAJdQgg=jJYfdRsq+QfBr1aC-hS1ft9+4Sp4jopoktg=JnDMirg@mail.
>> gmail.com>
>> Content-Type: text/plain; charset="utf-8"
>>
>> Hi, can someone explain to me why i cannot define meanList as:
>>
>> meanList :: (Integral a, Fractional b) => [a] -> a
>> meanList xs = (sumList xs) / (lengthList xs)
>>
>> I want to restrict the function to only accept lists like [1,2,3] and
>>
>>
>> sumList :: (Num a) => [a] -> a
>> sumList [] = 0
>> sumList (x:xs) = x + (sumList xs)
>>
>> lengthList :: (Num a) => [t] -> a
>> lengthList [] = 0
>> lengthList (_:xs) = 1 + (lengthList xs)
>> -------------- next part --------------
>> An HTML attachment was scrubbed...
>> 20160922/45389bc3/attachment-0001.html>
>>
>> ------------------------------
>>
>> Message: 2
>> Date: Thu, 22 Sep 2016 19:36:04 +0530
>> From: Tushar Tyagi <tusha...@gmail.com>
>> To: The Haskell-Beginners Mailing List - Discussion of primarily
>>         constraints
>> Message-ID:
>>         <CAEDPzin_vcZA+hh9ZLFo-k91Bn63vaemgQJKqN_P4hsAk+ALzQ@mail.
>> gmail.com>
>> Content-Type: text/plain; charset="utf-8"
>>
>> What happens if you change the signature of meanList to
>>
>> meanList :: ( Fractional b) => [b] ->b
>>
>> The integrals in [1,2,3] would be converted to [1.0, 2.0, 3.0] before you
>> act upon them.
>>
>> On 22 Sep 2016 6:49 p.m., "Lai Boon Hui" <laibo...@gmail.com> wrote:
>>
>> Hi, can someone explain to me why i cannot define meanList as:
>>
>> meanList :: (Integral a, Fractional b) => [a] -> a
>> meanList xs = (sumList xs) / (lengthList xs)
>>
>> I want to restrict the function to only accept lists like [1,2,3] and
>>
>>
>> sumList :: (Num a) => [a] -> a
>> sumList [] = 0
>> sumList (x:xs) = x + (sumList xs)
>>
>> lengthList :: (Num a) => [t] -> a
>> lengthList [] = 0
>> lengthList (_:xs) = 1 + (lengthList xs)
>>
>>
>>
>> _______________________________________________
>> Beginners mailing list
>> -------------- next part --------------
>> An HTML attachment was scrubbed...
>> 20160922/a092897b/attachment-0001.html>
>>
>> ------------------------------
>>
>> Message: 3
>> Date: Thu, 22 Sep 2016 16:06:52 +0200
>> From: Imants Cekusins <ima...@gmail.com>
>> To: The Haskell-Beginners Mailing List - Discussion of primarily
>>         constraints
>> Message-ID:
>>         <cap1qinzcona4x3nozrifynbkkgurfbmcfp2r3wmoz6h3alg...@mail.gm
>> ail.com>
>> Content-Type: text/plain; charset="utf-8"
>>
>> Hello,
>>
>> this works too:
>>
>> ​meanList :: (Fractional a) => [a] -> a
>> meanList xs = (sumList xs) / (lengthList xs)
>>
>>
>> sumList :: (Fractional a) => [a] -> a
>> sumList [] = 0
>> sumList (x:xs) = x + (sumList xs)
>>
>>
>> lengthList :: (Fractional a) => [t] -> a
>> lengthList [] = 0
>> lengthList (_:xs) = 1 + (lengthList xs)
>> -------------- next part --------------
>> An HTML attachment was scrubbed...
>> 20160922/4c967a0d/attachment-0001.html>
>>
>> ------------------------------
>>
>> Message: 4
>> Date: Thu, 22 Sep 2016 16:08:56 +0200
>> From: Harald Bögeholz <b...@ct.de>
>> To: The Haskell-Beginners Mailing List - Discussion of primarily
>>         constraints
>> Message-ID: <a134a975-6b0f-b364-7db9-6b6a0d997...@ct.de>
>> Content-Type: text/plain; charset=utf-8
>>
>> Am 22.09.16 um 15:19 schrieb Lai Boon Hui:
>> > Hi, can someone explain to me why i cannot define meanList as:
>> >
>> > meanList :: (Integral a, Fractional b) => [a] -> a
>> > meanList xs = (sumList xs) / (lengthList xs)
>> >
>> > I want to restrict the function to only accept lists like [1,2,3] and
>>
>> It will work like this:
>>
>> meanList :: (Integral a, Fractional b) => [a] -> b
>> meanList xs = fromIntegral (sumList xs) / (lengthList xs)
>>
>> You probably meant -> b in the type signature, that was a typo.
>>
>> And you need to insert fromIntegral to convert to Fractional before you
>> can divide. Now that I see it I am beginning to wonder why it works,
>> though, because I was just about to insert another fromIntegral before
>> lengthList ...
>>
>>
>> > sumList :: (Num a) => [a] -> a
>> > sumList [] = 0
>> > sumList (x:xs) = x + (sumList xs)
>> >
>> > lengthList :: (Num a) => [t] -> a
>> > lengthList [] = 0
>> > lengthList (_:xs) = 1 + (lengthList xs)
>>
>> Hope this helps
>>
>>
>> --
>> Harald Bögeholz    <b...@ct.de> (PGP key available from servers)
>> Redaktion c't      Tel.: +49 511 5352-300  Fax: +49 511 5352-417
>>
>>                    int f[9814],b,c=9814,g,i;long a=1e4,d,e,h;
>>                    main(){for(;b=c,c-=14;i=printf("%04d",e+d/a),e=d%a)
>>                    while(g=--b*2)d=h*b+a*(i?f[b]:a/5),h=d/--g,f[b]=d%g;}
>>                                                           (Arndt/Haenel)
>>
>>                    Affe Apfel Vergaser
>>
>> /*Heise Medien GmbH & Co. KG * Karl-Wiechert-Allee 10 * 30625 Hannover
>> Registergericht: Amtsgericht Hannover HRA 26709
>> Persönlich haftende Gesellschafterin: Heise Medien Geschäftsführung GmbH
>> Registergericht: Amtsgericht Hannover, HRB 60405
>> Geschäftsführer: Ansgar Heise, Dr. Alfons Schräder*/
>>
>>
>> ------------------------------
>>
>> Message: 5
>> Date: Thu, 22 Sep 2016 16:10:17 +0200
>>         constraints
>> Content-Type: text/plain; charset="utf-8"; Format="flowed"
>>
>> Hi,
>>
>> You can define it, but in practice there is no instance of "a" that
>> satisfies both constraints: Integral a and Fractional a
>>  > meanList ([1,2,3] :: [Int])
>>
>> <interactive>:4:1: error:
>>      • No instance for (Fractional Int) arising from a use of ‘meanList’
>>
>>  > meanList ([1,2,3] :: [Float])
>>
>> <interactive>:5:1: error:
>>      • No instance for (Integral Float) arising from a use of ‘meanList’
>>
>> What you probably want is:
>> meanList :: (Integral a, Fractional b) => [a] -> b
>> meanList xs = fromIntegral (sumList xs) / fromIntegral (lengthList xs)
>>
>> Where we convert from the integral type "a" to the fractional type "b"
>> before performing the division.
>>
>>  > meanList ([1,2,3] :: [Int])
>> 2.0
>>
>> Cheers
>> Sylvain
>>
>>
>> On 22/09/2016 15:19, Lai Boon Hui wrote:
>> > Hi, can someone explain to me why i cannot define meanList as:
>> >
>> > meanList :: (Integral a, Fractional b) => [a] -> a
>> > meanList xs = (sumList xs) / (lengthList xs)
>> >
>> > I want to restrict the function to only accept lists like [1,2,3] and
>> >
>> >
>> > sumList :: (Num a) => [a] -> a
>> > sumList [] = 0
>> > sumList (x:xs) = x + (sumList xs)
>> >
>> > lengthList :: (Num a) => [t] -> a
>> > lengthList [] = 0
>> > lengthList (_:xs) = 1 + (lengthList xs)
>> >
>> >
>> >
>> >
>> > _______________________________________________
>> > Beginners mailing list
>>
>> -------------- next part --------------
>> An HTML attachment was scrubbed...
>> 20160922/1be73068/attachment-0001.html>
>>
>> ------------------------------
>>
>> Message: 6
>> Date: Thu, 22 Sep 2016 16:14:48 +0200
>>         constraints
>> Content-Type: text/plain; charset=utf-8; format=flowed
>>
>> On 22/09/2016 16:08, Harald Bögeholz wrote:
>> > It will work like this:
>> > meanList :: (Integral a, Fractional b) => [a] -> b
>> > meanList xs = fromIntegral (sumList xs) / (lengthList xs)
>> >
>> > You probably meant -> b in the type signature, that was a typo.
>> >
>> > And you need to insert fromIntegral to convert to Fractional before you
>> > can divide. Now that I see it I am beginning to wonder why it works,
>> > though, because I was just about to insert another fromIntegral before
>> > lengthList ...
>> It works because in this case lengthList uses the fractional type b to
>> perfom its summation (it doesn't care about the type of the elements in
>> xs).
>>
>> Cheers
>> Sylvain
>>
>>
>> ------------------------------
>>
>> Message: 7
>> Date: Thu, 22 Sep 2016 17:26:36 -0600
>> From: Dimitri DeFigueiredo <defigueir...@ucdavis.edu>
>>         Mailing List - Discussion of primarily beginner-level topics
>> related
>> Subject: [Haskell-beginners] The meaning of categories constructed
>> Message-ID: <36383e22-0b32-426d-7c9f-5e611bbca...@ucdavis.edu>
>> Content-Type: text/plain; charset=utf-8
>>
>> In category theory, there are many ways one can make new categories out
>> of an old one.
>>
>> In particular, given a category C one can construct:
>>
>> 1. The arrows category of C:
>>         arrows in C become objects and
>>         commutative squares in C become arrows
>> 2. The slice category of C given an object A:
>>         arrows into a distinguished object A become objects in the slice
>>         commutative triangles become arrows
>>
>> There are also functors going from C to these new categories (and back).
>>
>> Are these constructed categories useful when C = `Hask` (the category of
>> What do they represent in programming terms?
>>
>> In other words, is there intuition for what the arrows category of Hask
>> is?
>> What about the slice category of Hask over a specific type?
>> Do the functors between these match some programming abstractions?
>>
>> Any pointers are much appreciated.
>>
>> Thanks,
>>
>> Dimitri
>>
>>
>>
>>
>> ------------------------------
>>
>> Subject: Digest Footer
>>
>> _______________________________________________
>> Beginners mailing list
>>
>>
>> ------------------------------
>>
>> End of Beginners Digest, Vol 99, Issue 13
>> *****************************************
>>
>
>
>
> --
> Best Regards,
> Boon Hui
>
> _______________________________________________
> Beginners mailing list
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:

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

Subject: Digest Footer

_______________________________________________
Beginners mailing list