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. Re: Ratio data constructor (Bob Ippolito)
2. Re: Ratio data constructor (Galaxy Being)
3. Re: Ratio data constructor (Bob Ippolito)
----------------------------------------------------------------------
Message: 1
Date: Tue, 20 Jul 2021 14:36:41 -0700
From: Bob Ippolito <b...@redivi.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Ratio data constructor
Message-ID:
<cacwmpm9fcpjt6ksvksqnydrrlv47u_j0om-62oypehmmjlm...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Yes, the (%) function is a smart constructor for Data.Ratio because the
(:%) constructor is not exported. Other examples of this smart constructor
technique would be modules like Data.Set or Data.Map.
A smart constructor means that the module that defines the type does not
export its data constructor(s), making the implementation details
opaque, generally because the author wanted to be able to make assumptions
about the implementation that are not enforced by the type system. In this
case, they wanted all Ratio to be in reduced form. This makes many
operations faster or trivial, e.g. implementing Eq only requires comparing
the numerators and denominators. More information about the technique is
here: https://wiki.haskell.org/Smart_constructors
On Tue, Jul 20, 2021 at 2:17 PM Galaxy Being <borg...@gmail.com> wrote:
> ... does the last question have to do with a "smart constructor" by
> chance? If so, how?
>
> On Tue, Jul 20, 2021 at 3:42 PM Galaxy Being <borg...@gmail.com> wrote:
>
>> I'm investigating rational numbers with Haskell. This is the source I've
>> found
>>
>> data Ratio a = !a :% !a deriving (Eq)
>>
>> reduce :: (Integral a) => a -> a -> Ratio a
>> {-# SPECIALISE reduce :: Integer -> Integer -> Rational #-}
>> reduce _ 0 = ratioZeroDenominatorError
>> reduce x y = (x `quot` d) :% (y `quot` d)
>> where d = gcd x y
>> (%) :: (Integral a) => a -> a -> Ratio a
>> x % y = reduce (x * signum y) (abs y)
>>
>> The Ratio data type would seem to be a parameterized type with two
>> parameters of the same type that must be "settled" in that they're not to
>> be lazily dealt with. Then the :% is the data constructor, the : meaning
>> it's a data constructor and not just an operation function. So this could
>> have been
>>
>> data Ratio a = :% !a !a deriving (Eq)
>>
>> correct? But then what confuses me is in reduce, why
>>
>> reduce x y = (x `quot` d) :% (y `quot` d)
>>
>> and not just %? We have :% defined in the data type and then (%) defined
>> as a function. What is going on here?
>>
>> --
>> ⨽
>> Lawrence Bottorff
>> Grand Marais, MN, USA
>> borg...@gmail.com
>>
>
>
> --
> ⨽
> Lawrence Bottorff
> Grand Marais, MN, USA
> borg...@gmail.com
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210720/c2338c14/attachment-0001.html>
------------------------------
Message: 2
Date: Tue, 20 Jul 2021 17:09:56 -0500
From: Galaxy Being <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Ratio data constructor
Message-ID:
<cafahfsushpdgq1r3mip1hbgpxu609ooqfidvkxqb+choprw...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Yes, I see here
<http://support.hfm.io/1.0/api/haskell2010-1.1.2.0/Data-Ratio.html> that
the module Data.Ratio exports this
module Data.Ratio (
Ratio, Rational, (%), numerator, denominator, approxRational ) where
which doesn't include :%. But then I see numerator and denominator which
do have :%. But then to use them, this, e.g., won't work
numerator (60 20)
It needs the %
numerator (60 % 20)
So internally, :% is used, but users can never use :%, only %, which sends
things through reduce first. I could write my own version of Ratio that
didn't hide :<some symbol> and that would be okay. Have I got this right?
On Tue, Jul 20, 2021 at 4:37 PM Bob Ippolito <b...@redivi.com> wrote:
> Yes, the (%) function is a smart constructor for Data.Ratio because the
> (:%) constructor is not exported. Other examples of this smart constructor
> technique would be modules like Data.Set or Data.Map.
>
> A smart constructor means that the module that defines the type does not
> export its data constructor(s), making the implementation details
> opaque, generally because the author wanted to be able to make assumptions
> about the implementation that are not enforced by the type system. In this
> case, they wanted all Ratio to be in reduced form. This makes many
> operations faster or trivial, e.g. implementing Eq only requires comparing
> the numerators and denominators. More information about the technique is
> here: https://wiki.haskell.org/Smart_constructors
>
>
>
> On Tue, Jul 20, 2021 at 2:17 PM Galaxy Being <borg...@gmail.com> wrote:
>
>> ... does the last question have to do with a "smart constructor" by
>> chance? If so, how?
>>
>> On Tue, Jul 20, 2021 at 3:42 PM Galaxy Being <borg...@gmail.com> wrote:
>>
>>> I'm investigating rational numbers with Haskell. This is the source I've
>>> found
>>>
>>> data Ratio a = !a :% !a deriving (Eq)
>>>
>>> reduce :: (Integral a) => a -> a -> Ratio a
>>> {-# SPECIALISE reduce :: Integer -> Integer -> Rational #-}
>>> reduce _ 0 = ratioZeroDenominatorError
>>> reduce x y = (x `quot` d) :% (y `quot` d)
>>> where d = gcd x y
>>> (%) :: (Integral a) => a -> a -> Ratio a
>>> x % y = reduce (x * signum y) (abs y)
>>>
>>> The Ratio data type would seem to be a parameterized type with two
>>> parameters of the same type that must be "settled" in that they're not to
>>> be lazily dealt with. Then the :% is the data constructor, the :
>>> meaning it's a data constructor and not just an operation function. So this
>>> could have been
>>>
>>> data Ratio a = :% !a !a deriving (Eq)
>>>
>>> correct? But then what confuses me is in reduce, why
>>>
>>> reduce x y = (x `quot` d) :% (y `quot` d)
>>>
>>> and not just %? We have :% defined in the data type and then (%)
>>> defined as a function. What is going on here?
>>>
>>> --
>>> ⨽
>>> Lawrence Bottorff
>>> Grand Marais, MN, USA
>>> borg...@gmail.com
>>>
>>
>>
>> --
>> ⨽
>> Lawrence Bottorff
>> Grand Marais, MN, USA
>> borg...@gmail.com
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
--
⨽
Lawrence Bottorff
Grand Marais, MN, USA
borg...@gmail.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210720/9ef0d003/attachment-0001.html>
------------------------------
Message: 3
Date: Tue, 20 Jul 2021 17:58:03 -0700
From: Bob Ippolito <b...@redivi.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Ratio data constructor
Message-ID:
<cacwmpm8fuozxk5r2fhtg_rhbpxzyhcp4rojdtqnvnyjfjww...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
That sounds about right. numerator and denominator are deconstructors,
which you need to use to access the fields because you can’t pattern match
without access to the :% constructor. If you look at their implementation,
they are deconstructing with a pattern match rather than constructing like
the % function.
On Tue, Jul 20, 2021 at 15:10 Galaxy Being <borg...@gmail.com> wrote:
> Yes, I see here
> <http://support.hfm.io/1.0/api/haskell2010-1.1.2.0/Data-Ratio.html> that
> the module Data.Ratio exports this
>
> module Data.Ratio (
> Ratio, Rational, (%), numerator, denominator, approxRational ) where
>
> which doesn't include :%. But then I see numerator and denominator which
> do have :%. But then to use them, this, e.g., won't work
>
> numerator (60 20)
>
> It needs the %
>
> numerator (60 % 20)
>
> So internally, :% is used, but users can never use :%, only %, which
> sends things through reduce first. I could write my own version of Ratio
> that didn't hide :<some symbol> and that would be okay. Have I got this
> right?
>
>
>
> On Tue, Jul 20, 2021 at 4:37 PM Bob Ippolito <b...@redivi.com> wrote:
>
>> Yes, the (%) function is a smart constructor for Data.Ratio because the
>> (:%) constructor is not exported. Other examples of this smart constructor
>> technique would be modules like Data.Set or Data.Map.
>>
>> A smart constructor means that the module that defines the type does not
>> export its data constructor(s), making the implementation details
>> opaque, generally because the author wanted to be able to make assumptions
>> about the implementation that are not enforced by the type system. In this
>> case, they wanted all Ratio to be in reduced form. This makes many
>> operations faster or trivial, e.g. implementing Eq only requires comparing
>> the numerators and denominators. More information about the technique is
>> here: https://wiki.haskell.org/Smart_constructors
>>
>>
>>
>> On Tue, Jul 20, 2021 at 2:17 PM Galaxy Being <borg...@gmail.com> wrote:
>>
>>> ... does the last question have to do with a "smart constructor" by
>>> chance? If so, how?
>>>
>>> On Tue, Jul 20, 2021 at 3:42 PM Galaxy Being <borg...@gmail.com> wrote:
>>>
>>>> I'm investigating rational numbers with Haskell. This is the source
>>>> I've found
>>>>
>>>> data Ratio a = !a :% !a deriving (Eq)
>>>>
>>>> reduce :: (Integral a) => a -> a -> Ratio a
>>>> {-# SPECIALISE reduce :: Integer -> Integer -> Rational #-}
>>>> reduce _ 0 = ratioZeroDenominatorError
>>>> reduce x y = (x `quot` d) :% (y `quot` d)
>>>> where d = gcd x y
>>>> (%) :: (Integral a) => a -> a -> Ratio a
>>>> x % y = reduce (x * signum y) (abs y)
>>>>
>>>> The Ratio data type would seem to be a parameterized type with two
>>>> parameters of the same type that must be "settled" in that they're not to
>>>> be lazily dealt with. Then the :% is the data constructor, the :
>>>> meaning it's a data constructor and not just an operation function. So this
>>>> could have been
>>>>
>>>> data Ratio a = :% !a !a deriving (Eq)
>>>>
>>>> correct? But then what confuses me is in reduce, why
>>>>
>>>> reduce x y = (x `quot` d) :% (y `quot` d)
>>>>
>>>> and not just %? We have :% defined in the data type and then (%)
>>>> defined as a function. What is going on here?
>>>>
>>>> --
>>>> ⨽
>>>> Lawrence Bottorff
>>>> Grand Marais, MN, USA
>>>> borg...@gmail.com
>>>>
>>>
>>>
>>> --
>>> ⨽
>>> Lawrence Bottorff
>>> Grand Marais, MN, USA
>>> borg...@gmail.com
>>> _______________________________________________
>>> Beginners mailing list
>>> Beginners@haskell.org
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
>
>
> --
> ⨽
> Lawrence Bottorff
> Grand Marais, MN, USA
> borg...@gmail.com
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210720/8fb718ec/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 156, Issue 5
*****************************************
