Just expanding on Brandon's answer: DeMorgan's law he's referring to goes like this:

∀a.P(a) === ¬∃a.¬P(a) where 'a' is a sentence, so P is second order

A special case of this is this:
∀a.(R(a) -> Q) === ¬∃a.¬(R(a) -> Q) === ¬∃a.(R(a)∧¬Q) === ¬((∃a.R(a))∧¬Q) === (∃a.R(a)) -> Q (i added extra parantheses for emphasis)

So what does this mean in terms of haskell? R(a) is your data definition's "body", and Q is the type you are defining. On the lhs the universally quantified version gives you the type of the constuctor you're defining, and on the rhs the existential tells you what you're constructing the type with.
Or in other words the universal version says: For any 'a' give me an R(a) and i'll give you back a Q.

The existential version says: If you have some 'a' for which R(a) i'll give you back a Q. (It's hard to phrase the difference without sounding stupid, they are equivalent after all).

There are of course other considerations, for example introducing 'exists' would mean another keyword in the syntax.

Having said that I think that the choice of 'forall' for -XExistentialQuantification is wrong, as the data body defines the type you're constructing with, not the type of the whole constructor. HOWEVER for -XGADTs forall makes perfect sense. Compare the following:

data AnyType = forall a. AnyType a

data AnyType where

AnyType :: forall a. a -> AnyType

These two definitions are operationally identical, but I think the GADT way is the one that actually corresponds to the DeMorgan law.

On 2 December 2013 22:07, TP <paratribulations@free.fr> wrote:

Hi everybody,

I try to understand existential quantification. I have two questions.

1/ I have just read the answer of yairchu at

http://stackoverflow.com/questions/3071136/what-does-the-forall-keyword-in-haskell-ghc-do

He writes:

"""
So with Existential-Quantification, foralls in data definitions mean that,
the value contained *can* be of *any* suitable type, not that it *must* be
of *all* suitable types.
"""

This made me think to an error I obtained with the code:
---------------
test :: Show s => s
test = "foobar"
---------------

The error is:

Could not deduce (s ~ [Char])
from the context (Show s)
bound by the type signature for test :: Show s => s
[...]
`s' is a rigid type variable bound by
the type signature for test :: Show s => s

Indeed, `test :: Show s => s` means "for any type s which is an instance of
Show, test is a value of that type s". But for example "foobar" can't be an
Int that is an instance of Show, so it yields an error.
By comparison,

---------------
test :: Num a => a
test = 42
---------------

works because 42 can be a value of type Int or Integer or Float or anything
else that is an instance of Num.
So I thought that by using existential quantification, the first example
could work:

---------------
{-# LANGUAGE ExistentialQuantification #-}

test :: forall s . Show s => s
test = "asd"
---------------

But I obtain the same error, why?

2/
Is the notion of existential type related in some way to the classical
mathematical quantifier "∃" (Unicode symbol U+2203: "There exists")?
If yes, then why using "forall" for an "existential type"?

At the following address

http://www.haskell.org/ghc/docs/6.12.1/html/users_guide/data-type-extensions.html#existential

we read

"""
7.4.4.1. Why existential?

What has this to do with existential quantification? Simply that MkFoo has
the (nearly) isomorphic type

MkFoo :: (exists a . (a, a -> Bool)) -> Foo

But Haskell programmers can safely think of the ordinary universally
quantified type given above, thereby avoiding adding a new existential
quantification construct.
"""

But I don't understand the explanation.

Thanks in advance,

TP

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe