At [EMAIL PROTECTED] I asked the following:
this works
data Exists f = forall x . E ( f x)
this doesn't work
newtype Exists f = forall x . E ( f x)
Hugs accepts both.
It there a reason why existential quantification does not work with a
newtype, or is it just
a parser problem?
This problem is clearly not a bug but a restriction imposed by the designers
of GHC,
as Keith Wansbrough pointed out to me:
From the manual, section 7.12.3 Restrictions:
--8--
You can't use existential quantification for newtype declarations. So this
is illegal:
newtype T = forall a. Ord a = MkT a
Reason: a value of type T must be represented as a pair of a
dictionary for Ord t and a value of type t. That contradicts the idea
that newtype should have no concrete representation. You can get just
the same efficiency and effect by using data instead of newtype. If
there is no overloading involved, then there is more of a case for
allowing an existentially-quantified newtype, because the data because
the data version does carry an implementation cost, but single-field
existentially quantified constructors aren't much use. So the simple
restriction (no existential stuff on newtype) stands, unless there are
convincing reasons to change it.
--8--
I perfectly understand why the use of class constraints in combination with
newtype and existential quantification is
illegal. In my opinion the restriction should only forbit this particular
combination, instead of all uses of newtype with existentials.
For me single-field existentially quantified constructors are quite useful:
For example
newtype Exists f = forall x . E (f x)
data Object a = Object {value :: a , toString:: a - String }
data Thing a = Thing {val :: a , next :: a - a, run :: a - IO ()}
-- Here I hide the type variables of Object and Thing using the type Exists:
type EObject = Exists Object
type EThing= Exists Thing
without single-field existentially quantified constructors I would have to
write:
data EObject = forall a . EObject a (a - String)
data EThing = forall a . EThing a (a - a) (a- IO ())
or write the Exists type using data
When using data I have to pay a (however small) run-time cost, that I would
not have to pay
when using a newtype.
The other solution does not have this run-time cost, but it makes my code
less readable:
I have to invent new types and constructor names.
I cannot use named fields.
I cannot reuse polymorphic functions that work on Object on EObjects.
Summarizing: without single-field existentially quantified constructors in
newtypes
either my code gets less readable or I have to pay a run-time price.
Is it possible to relax the restriction on newtypes in combination with
existentials?
Cheers, Arthur
___
Glasgow-haskell-users mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
