Changes between Version 8 and Version 9 of ScopedTypeVariables

Timestamp:

01/07/06 06:45:09 (7 years ago)

Author:

ross@…

Comment:

--

ScopedTypeVariables

@@ -6 +6 @@
 == Brief Explanation ==
 
-Type annotations, which Haskell 98 allows in expressions, are also allowed in patterns and (currently in GHC only) in result type signatures, attached to the left side of a function definition.  New type variables in these annotations scope over the function body, permitting locally defined variables to be given signatures in situations where it would be impossible in Haskell 98, e.g.
+In Haskell 98, it is sometimes impossible to give a signature for a locally defined variable, e.g. `cmp` in
 {{{
 sortImage :: Ord b => (a -> b) -> [a] -> [a]
+sortImage f = sortBy cmp
+  where cmp x y = compare (f x) (f y)
+}}}
+The argument type of `cmp` is the type `a` in the signature of `sortImage`, but there is no way to refer to it in a type signature.
+Quantification of type variables over expressions is needed.
+
+GHC provides three extensions that bind type variables:
+
+ * Explicit `forall`s in type signature declarations.
+   The bound variables scope over the function body, e.g.
+   {{{
+sortImage :: forall a b. Ord b => (a -> b) -> [a] -> [a]
+sortImage f = sortBy cmp
+  where cmp :: a -> a -> Ordering
+        cmp x y = compare (f x) (f y)
+}}}
+
+ * Pattern type signatures.
+   Free variables in the type stand for new types in the scope of the pattern, e.g.
+   {{{
 sortImage (f::a->b) = sortBy cmp
   where cmp :: a -> a -> Ordering
         cmp x y = compare (f x) (f y)
 }}}
+
+ * Result type signatures, giving the type of both sides of the equation.
+   Free variables in the type stand for new types in the scope, e.g.
+   {{{
+sortImage f :: [a] -> [a] = sortBy cmp
+  where cmp :: a -> a -> Ordering
+        cmp x y = compare (f x) (f y)
+}}}
+In the latter two cases, the variable can stand for any type, not necessarily a type variable is in these examples, i.e. the variable is existentially quantified.
+Hugs supports only pattern type signatures, with the type variables universally quantified.
+
+In GHC, type variables in instances heads also scope over the body of the instance.
 
 == References ==