[RFC] Bang constraint

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

[RFC] Bang constraint

Gabor Greif-2
Now that Constraint kinds are pretty much into the mainstream, can we
consider the '!' annotation in data declarations as a magic
constraint? Not unlike NFData, but only ensuring that said value is in
WHNF.

So the following definitions would be semantically identical

> newtype Foo a = Foo a

> data Foo a = Foo !a

> data Foo a = (!a) => Foo a

> data FooC :: (* -> Constraint) -> * -> * where
>   Foo :: c a => a -> FooC c a
> type Foo a = FooC ! a

It just occured to me and seemed plausible at first thought, but feel
free to flame me because of the magic-ness.

Cheers,

    Gabor


Reply | Threaded
Open this post in threaded view
|

[RFC] Bang constraint

Isaac Dupree-3
On 04/03/2013 02:06 PM, Gabor Greif wrote:

> Now that Constraint kinds are pretty much into the mainstream, can we
> consider the '!' annotation in data declarations as a magic
> constraint? Not unlike NFData, but only ensuring that said value is in
> WHNF.
>
> So the following definitions would be semantically identical
>
>> newtype Foo a = Foo a
>
>> data Foo a = Foo !a
> [...]

These two are not identical because
   f (Foo _) = 3
forces the value if it's 'data' but not if it's 'newtype'.
That's irrelevant to your interesting proposal, however.

-Isaac


Reply | Threaded
Open this post in threaded view
|

[RFC] Bang constraint

Roman Cheplyaka-2
In reply to this post by Gabor Greif-2
So, what exactly does this constraint mean outside of data declarations?

E.g. how do we interpret

  f :: (!a) => a -> a -> a

?

* Gabor Greif <ggreif at gmail.com> [2013-04-03 20:06:03+0200]

> Now that Constraint kinds are pretty much into the mainstream, can we
> consider the '!' annotation in data declarations as a magic
> constraint? Not unlike NFData, but only ensuring that said value is in
> WHNF.
>
> So the following definitions would be semantically identical
>
> > newtype Foo a = Foo a
>
> > data Foo a = Foo !a
>
> > data Foo a = (!a) => Foo a
>
> > data FooC :: (* -> Constraint) -> * -> * where
> >   Foo :: c a => a -> FooC c a
> > type Foo a = FooC ! a
>
> It just occured to me and seemed plausible at first thought, but feel
> free to flame me because of the magic-ness.
>
> Cheers,
>
>     Gabor
>
> _______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://www.haskell.org/mailman/listinfo/ghc-devs


Reply | Threaded
Open this post in threaded view
|

[RFC] Bang constraint

Gabor Greif-2
Hi Roman,

I'd say it would be an empty constraint, since the directory
associated with (!) is empty. So this would be trivially satisfied.

There is however another possibility, something like `seq`. So both
arguments would always be normalized to WHNF before the function f is
called. Same for the result. Of course this constraint still would not
rule out

> f a b = f a b

so no big gain here.

Implementing the latter would be more ambitious, introducing basically
the same sort of 'magic' as with ! on data.

Cheers,

    Gabor

On 4/3/13, Roman Cheplyaka <roma at ro-che.info> wrote:

> So, what exactly does this constraint mean outside of data declarations?
>
> E.g. how do we interpret
>
>   f :: (!a) => a -> a -> a
>
> ?
>
> * Gabor Greif <ggreif at gmail.com> [2013-04-03 20:06:03+0200]
>> Now that Constraint kinds are pretty much into the mainstream, can we
>> consider the '!' annotation in data declarations as a magic
>> constraint? Not unlike NFData, but only ensuring that said value is in
>> WHNF.
>>
>> So the following definitions would be semantically identical
>>
>> > newtype Foo a = Foo a
>>
>> > data Foo a = Foo !a
>>
>> > data Foo a = (!a) => Foo a
>>
>> > data FooC :: (* -> Constraint) -> * -> * where
>> >   Foo :: c a => a -> FooC c a
>> > type Foo a = FooC ! a
>>
>> It just occured to me and seemed plausible at first thought, but feel
>> free to flame me because of the magic-ness.
>>
>> Cheers,
>>
>>     Gabor
>>
>> _______________________________________________
>> ghc-devs mailing list
>> ghc-devs at haskell.org
>> http://www.haskell.org/mailman/listinfo/ghc-devs
>


Reply | Threaded
Open this post in threaded view
|

[RFC] Bang constraint

Simon Peyton Jones
In reply to this post by Gabor Greif-2
I don't think so.  It's very magic in many ways; more than invoking methods.  Eg when pattern matching we know that the thing is evaluated, and so don't need to re-seq it when re-building a similar constructor.  And it's not clear what would be gained.

A long time ago, seq had this type
        class Eval a where
          seq :: a -> b -> b
which was a very good, principled thing to do.  One of Haskell's few compromises with reality was to make seq polymorphic.

Simon

| -----Original Message-----
| From: ghc-devs-bounces at haskell.org [mailto:ghc-devs-bounces at haskell.org]
| On Behalf Of Gabor Greif
| Sent: 03 April 2013 19:06
| To: ghc-devs
| Subject: [RFC] Bang constraint
|
| Now that Constraint kinds are pretty much into the mainstream, can we
| consider the '!' annotation in data declarations as a magic constraint?
| Not unlike NFData, but only ensuring that said value is in WHNF.
|
| So the following definitions would be semantically identical
|
| > newtype Foo a = Foo a
|
| > data Foo a = Foo !a
|
| > data Foo a = (!a) => Foo a
|
| > data FooC :: (* -> Constraint) -> * -> * where
| >   Foo :: c a => a -> FooC c a
| > type Foo a = FooC ! a
|
| It just occured to me and seemed plausible at first thought, but feel
| free to flame me because of the magic-ness.
|
| Cheers,
|
|     Gabor
|
| _______________________________________________
| ghc-devs mailing list
| ghc-devs at haskell.org
| http://www.haskell.org/mailman/listinfo/ghc-devs