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. Restrict type in phantom data-type (Baa)
2. Re: Restrict type in phantom data-type (David McBride)
3. Re: Restrict type in phantom data-type (Francesco Ariis)
4. Re: Restrict type in phantom data-type (Francesco Ariis)
5. Re: Restrict type in phantom data-type (Baa)
6. Re: Restrict type in phantom data-type (Baa)
7. Re: Restrict type in phantom data-type (David McBride)
----------------------------------------------------------------------
Message: 1
Date: Fri, 1 Sep 2017 17:18:02 +0300
From: Baa <aqua...@gmail.com>
To: Haskell <beginners@haskell.org>
Subject: [Haskell-beginners] Restrict type in phantom data-type
Message-ID: <20170901171802.2819db2e@Pavel>
Content-Type: text/plain; charset=US-ASCII
Hello, List!
For example, I have specialized (right nameis phantom?) type:
data Day a = Day { ... no `a` here }
data Sunny
data Rainy
joyToday :: Day Sunny -> IO ()
joyToday day = ...
melancholyToday :: Day Rainy -> IO ()
melancholyToday day = ...
And I can create (in spite of that it's phantom) some day:
let day1 = Day {...} :: Day Sunny
joyToday day1
but no problem to create `Day Int`, `Day Char`, etc which is
pointless actually (sure "creator"-function can be exported from the
module only, but I'm talking about type-level solution).
I know that constraints (`... =>`) on data types are redundant/removed
from the language. And I'm not sure how it's possible to restrict that
parameter `a` (I know that it's possible to Java/C++/Perl6 (not sure),
some other languages but how to add such restriction in Haskell? IMHO
type families can help but I'm not sure how it will look (Sunny, Rainy
are "nullary" type, so...).
Is it possible for Haskell too?
===
Best regards, Paul
------------------------------
Message: 2
Date: Fri, 1 Sep 2017 10:50:09 -0400
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID:
<can+tr43tx-vcpc_f2t1ky0gw4rowznufn4g7fbaq0b6rsjw...@mail.gmail.com>
Content-Type: text/plain; charset="UTF-8"
This is maybe edging toward haskell-cafe territory, but you can
definitely do this in haskell.
{-# LANGUAGE DataKinds, KindSignatures #-}
data DayType = Sunny | Rainy
data Day (a :: DayType) = Day
sunnyDay :: Day Sunny
sunnyDay = Day
rainyDay :: Day Rainy
rainyDay = Day
-- impossibleDay :: Day ()
-- impossibleDay = Day
On Fri, Sep 1, 2017 at 10:18 AM, Baa <aqua...@gmail.com> wrote:
> Hello, List!
>
> For example, I have specialized (right nameis phantom?) type:
>
> data Day a = Day { ... no `a` here }
> data Sunny
> data Rainy
>
> joyToday :: Day Sunny -> IO ()
> joyToday day = ...
>
> melancholyToday :: Day Rainy -> IO ()
> melancholyToday day = ...
>
> And I can create (in spite of that it's phantom) some day:
>
> let day1 = Day {...} :: Day Sunny
> joyToday day1
>
> but no problem to create `Day Int`, `Day Char`, etc which is
> pointless actually (sure "creator"-function can be exported from the
> module only, but I'm talking about type-level solution).
>
> I know that constraints (`... =>`) on data types are redundant/removed
> from the language. And I'm not sure how it's possible to restrict that
> parameter `a` (I know that it's possible to Java/C++/Perl6 (not sure),
> some other languages but how to add such restriction in Haskell? IMHO
> type families can help but I'm not sure how it will look (Sunny, Rainy
> are "nullary" type, so...).
>
> Is it possible for Haskell too?
>
> ===
> Best regards, Paul
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Message: 3
Date: Fri, 1 Sep 2017 16:55:32 +0200
From: Francesco Ariis <fa...@ariis.it>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID: <20170901145532.74p6tullydcko...@x60s.casa>
Content-Type: text/plain; charset=us-ascii
On Fri, Sep 01, 2017 at 05:18:02PM +0300, Baa wrote:
> Hello, List!
>
> For example, I have specialized (right nameis phantom?) type:
>
> data Day a = Day { ... no `a` here }
> data Sunny
> data Rainy
>
> joyToday :: Day Sunny -> IO ()
> joyToday day = ...
>
> melancholyToday :: Day Rainy -> IO ()
> melancholyToday day = ...
>
> And I can create (in spite of that it's phantom) some day:
>
> let day1 = Day {...} :: Day Sunny
> joyToday day1
Hello Paul,
the usual way is create a module and export `smart` constructors:
module MyType (rainy, Day, Sunny) -- *not* Day
rainy :: Day Rainy
rainy = undefined -- something here
That way you can use Day for time signatures but *not* `Day` the
constructor.
Does this solve your problem?
------------------------------
Message: 4
Date: Fri, 1 Sep 2017 16:57:58 +0200
From: Francesco Ariis <fa...@ariis.it>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID: <20170901145758.6cyarxv6l6sl5...@x60s.casa>
Content-Type: text/plain; charset=us-ascii
On Fri, Sep 01, 2017 at 04:55:32PM +0200, Francesco Ariis wrote:
> module MyType (rainy, Day, Sunny) -- *not* Day
I meant to write: -- not `Day(..)`
------------------------------
Message: 5
Date: Fri, 1 Sep 2017 18:06:19 +0300
From: Baa <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID: <20170901180619.598c255c@Pavel>
Content-Type: text/plain; charset=US-ASCII
@Francesco: yes, it's a solution. But more interesting here is to make
it on type level, like we do it in D, Java, etc where you can say:
"class derived from...", "class before...", "class after...".
> On Fri, Sep 01, 2017 at 04:55:32PM +0200, Francesco Ariis wrote:
> > module MyType (rainy, Day, Sunny) -- *not* Day
>
> I meant to write: -- not `Day(..)`
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Message: 6
Date: Fri, 1 Sep 2017 18:23:27 +0300
From: Baa <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID: <20170901182327.1d673162@Pavel>
Content-Type: text/plain; charset=US-ASCII
I pereputal emails.
---
David, hello!
1. Is it the same/different as:
data family Day a
data Sunny
data Rainy
data instance Day Sunny = SunnyDay deriving Show
data instance Day Rainy = RainyDay deriving Show
..and here you can not create `Day Int` object because no `Day Int`
constructor (but you can create such constructor)
? Or in case with type families there is possibility to extend it to
`Day Int` and in case with DayaKinds it's totally impossible?
2. I read somewhere (on forums) that restrictions on data types... I
don't remember exactly, but something like they are not real
restrictions or are related to old extension which is/will be
deprecated. I'm not sure. Also, I'm not sure is it - in your example -
restriction (constraint) or something else. Am I wrong?
> This is maybe edging toward haskell-cafe territory, but you can
> definitely do this in haskell.
>
> {-# LANGUAGE DataKinds, KindSignatures #-}
>
> data DayType = Sunny | Rainy
>
> data Day (a :: DayType) = Day
>
>
> sunnyDay :: Day Sunny
> sunnyDay = Day
>
> rainyDay :: Day Rainy
> rainyDay = Day
>
> -- impossibleDay :: Day ()
> -- impossibleDay = Day
>
> On Fri, Sep 1, 2017 at 10:18 AM, Baa <aqua...@gmail.com> wrote:
> > Hello, List!
> >
> > For example, I have specialized (right nameis phantom?) type:
> >
> > data Day a = Day { ... no `a` here }
> > data Sunny
> > data Rainy
> >
> > joyToday :: Day Sunny -> IO ()
> > joyToday day = ...
> >
> > melancholyToday :: Day Rainy -> IO ()
> > melancholyToday day = ...
> >
> > And I can create (in spite of that it's phantom) some day:
> >
> > let day1 = Day {...} :: Day Sunny
> > joyToday day1
> >
> > but no problem to create `Day Int`, `Day Char`, etc which is
> > pointless actually (sure "creator"-function can be exported from the
> > module only, but I'm talking about type-level solution).
> >
> > I know that constraints (`... =>`) on data types are
> > redundant/removed from the language. And I'm not sure how it's
> > possible to restrict that parameter `a` (I know that it's possible
> > to Java/C++/Perl6 (not sure), some other languages but how to add
> > such restriction in Haskell? IMHO type families can help but I'm
> > not sure how it will look (Sunny, Rainy are "nullary" type, so...).
> >
> > Is it possible for Haskell too?
> >
> > ===
> > Best regards, Paul
> > _______________________________________________
> > 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
------------------------------
Message: 7
Date: Fri, 1 Sep 2017 12:19:13 -0400
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Restrict type in phantom data-type
Message-ID:
<can+tr43t_r8o1aynv-tv_nvj4swvq+v7ccr8r7vmrbromp8...@mail.gmail.com>
Content-Type: text/plain; charset="UTF-8"
The terminology for what you are looking for was phantom type. That
is any type that looks like this, where the a is not mentioned on the
right hand side.
data Foo a = Foo
What happens with datakinds is when you write
data SomeType = Foo | Bar
By default there is a type SomeType and two values Foo and Bar, which
are of kind *, which is the default. With datakinds enabled, it
creates two new types 'Foo, and 'Bar, which have a kind SomeType
(instead of *). You can replace Rainy with 'Rainy in the other code I
gave. It compiles either way because there is no other type Rainy, so
it assumes you must have meant 'Rainy.
As for type families, what you have there are called open type
families. There is also a closed type families variant that prevents
more instances of the type family from being declared by the library
user. It would look like this:
data Sunny
data Rainy
type family Night a where
Night Sunny = SunnyNight
Night Rainy = RainyNight
You could still write the following, which would not work in
datakinds, but at least there is no constructor that you could use
that would satisfy it other than the ones listed in the type family.
impossibleDay2 :: Day ()
impossibleDay2 = undefined
There may be more to this than I know, but I think that about covers it.
On Fri, Sep 1, 2017 at 11:23 AM, Baa <aqua...@gmail.com> wrote:
> I pereputal emails.
> ---
>
> David, hello!
>
> 1. Is it the same/different as:
>
> data family Day a
> data Sunny
> data Rainy
> data instance Day Sunny = SunnyDay deriving Show
> data instance Day Rainy = RainyDay deriving Show
>
> ..and here you can not create `Day Int` object because no `Day Int`
> constructor (but you can create such constructor)
>
> ? Or in case with type families there is possibility to extend it to
> `Day Int` and in case with DayaKinds it's totally impossible?
>
> 2. I read somewhere (on forums) that restrictions on data types... I
> don't remember exactly, but something like they are not real
> restrictions or are related to old extension which is/will be
> deprecated. I'm not sure. Also, I'm not sure is it - in your example -
> restriction (constraint) or something else. Am I wrong?
>
>> This is maybe edging toward haskell-cafe territory, but you can
>> definitely do this in haskell.
>>
>> {-# LANGUAGE DataKinds, KindSignatures #-}
>>
>> data DayType = Sunny | Rainy
>>
>> data Day (a :: DayType) = Day
>>
>>
>> sunnyDay :: Day Sunny
>> sunnyDay = Day
>>
>> rainyDay :: Day Rainy
>> rainyDay = Day
>>
>> -- impossibleDay :: Day ()
>> -- impossibleDay = Day
>>
>> On Fri, Sep 1, 2017 at 10:18 AM, Baa <aqua...@gmail.com> wrote:
>> > Hello, List!
>> >
>> > For example, I have specialized (right nameis phantom?) type:
>> >
>> > data Day a = Day { ... no `a` here }
>> > data Sunny
>> > data Rainy
>> >
>> > joyToday :: Day Sunny -> IO ()
>> > joyToday day = ...
>> >
>> > melancholyToday :: Day Rainy -> IO ()
>> > melancholyToday day = ...
>> >
>> > And I can create (in spite of that it's phantom) some day:
>> >
>> > let day1 = Day {...} :: Day Sunny
>> > joyToday day1
>> >
>> > but no problem to create `Day Int`, `Day Char`, etc which is
>> > pointless actually (sure "creator"-function can be exported from the
>> > module only, but I'm talking about type-level solution).
>> >
>> > I know that constraints (`... =>`) on data types are
>> > redundant/removed from the language. And I'm not sure how it's
>> > possible to restrict that parameter `a` (I know that it's possible
>> > to Java/C++/Perl6 (not sure), some other languages but how to add
>> > such restriction in Haskell? IMHO type families can help but I'm
>> > not sure how it will look (Sunny, Rainy are "nullary" type, so...).
>> >
>> > Is it possible for Haskell too?
>> >
>> > ===
>> > Best regards, Paul
>> > _______________________________________________
>> > 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
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 111, Issue 1
*****************************************
