On 12/02/2013 11:07 PM, TP wrote:
... 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?
This still says that 'test' is a value of type 's' for all 's' with a 'Show' instance. Basically, 'test' gets a type 's', an instance 'Show s' and we get a value of type 's'.
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...
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.
Generally speaking, a typing judgement x :: A can be interpreted as a proof that type 'A' is inhabited, or in other words, there exists a value of type 'A'. (Of course in Haskell this fact alone is trivial due to 'undefined', but additional reasoning could render it meaningful. For the remainder I'll just ignore the issue of lifting.) This is somewhat related to classical existential quantification, but it is stronger in a sense, since it says that we know how to construct such a value. (The classical version in general just says that the assumption that there is no such value leads to a contradiction.) Pattern matching allows one to get back the original constructor and the arguments used to construct a value of some ADT type. A universal quantifier over a type states that we can provide any type and obtain a value of the type provided in the body where all instances of the bound variable are replaced by our type. I.e. you can interpret forall a. (...) as stating that a value of that type takes an additional implicit argument 'a' at type level. Now MkFoo is declared as follows: data Foo = forall a. MkFoo a (a -> Bool) | Nil Which gives it the type: MkFoo :: forall a. a -> (a -> Bool) -> Foo I.e. it gets a type 'a' a value of that type and a decidable predicate ranging over that type and constructs a value of type 'Foo'. Pattern matching (roughly speaking) does the opposite: It gets you back a type, a value of that type and the predicate. The type is called nearly isomorphic to the explicit existential type, because using some rounds of pattern matching one would also recover the same kinds of objects. I.e. existential quantification can be thought of as being left implicit in the typing judgement, but 'forall' is needed in order to make explicit the scope of the type variable, which otherwise would range over the entire data declaration instead of just a single constructor. -XExistentialQuantification enables uses of 'forall' necessary for using existential quantification.