Difference between revisions of "Generalised algebraic datatype"
CaleGibbard (talk  contribs) 
(remove broken link, replace with corrected link) 

(32 intermediate revisions by 18 users not shown)  
Line 1:  Line 1:  
+  {{GHCUsersGuideexts/gadtgadta GADTs section}} 

+  
== Papers == 
== Papers == 

−  See also [[Research papers/Type systems#Generalised Algebraic Data Typesresearch papers on type systems]]. 
+  See also [[Research papers/Type systems#Generalised Algebraic Data Types (GADTs)research papers on type systems]]. 
−  * A short 
+  * A short description on generalised algebraic datatypes here [https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generalisedalgebraicdatatypesgadts as GHC language features]. 
−  * Another description with links on [http:// 
+  * Another description with links on [http://web.archive.org/web/20190404224609/http://prime.haskell.org/wiki/GADTs the archived Haskell' wiki]. 
−  * [http:// 
+  * [http://ecommons.library.cornell.edu/handle/1813/5614 FirstClass Phantom Types] by James Cheney and Ralf Hinze 
* [http://cristal.inria.fr/~fpottier/publis/pottierregisgianas05.pdf Stratified type inference for generalized algebraic data types] by François Pottier and Yann RégisGianas. It contains also a lot of links to other papers on GADTs. 
* [http://cristal.inria.fr/~fpottier/publis/pottierregisgianas05.pdf Stratified type inference for generalized algebraic data types] by François Pottier and Yann RégisGianas. It contains also a lot of links to other papers on GADTs. 

−  * [http://research.microsoft.com/ 
+  * [http://research.microsoft.com/enus/um/people/simonpj/papers/gadt/index.htm Simple unificationbased type inference for GADTs] by Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey Washburn. (Revised April 2006.) 
−  * [http://www. 
+  * [http://www.cs.mu.oz.au/~sulzmann/manuscript/simpletranslategadts.ps Translating Generalized Algebraic Data Types to System F] written by [http://www.cs.mu.oz.au/~sulzmann/ Martin Sulzmann] and Meng Wang. [http://www.cs.mu.oz.au/~sulzmann/2005.html Many other papers]. The talk mentions also the notion of [[phantom type]], and [[existential type]], and [[type witness]]. 
== Motivating example == 
== Motivating example == 

Line 41:  Line 43:  
eval x = x 
eval x = x 

</haskell> 
</haskell> 

−  Since the types of the socalled object language, being the typed SK calculus, are mimicked by the type system in our meta language, being 
+  Since the types of the socalled object language, being the typed SK calculus, are mimicked by the type system in our meta language, being Haskell, we have a pretty convincing argument that the evaluator won't mangle our types. We say that typing is preserved under evaluation (preservation.) Note that this is an argument and not a proof. 
This, however, comes at a price: let's see what happens when you try to convert strings into our object language: 
This, however, comes at a price: let's see what happens when you try to convert strings into our object language: 

Line 87:  Line 89:  
== Parsing Example == 
== Parsing Example == 

−  Note that GADTs provide a rather nice platform for embedded domain specific languages. In particular, they allow an EDSL to use Haskell's type system for its own purposes. As a simple example, we might have an EDSL for simple (regexplike) parsers that looks something like: 
+  Note that GADTs provide a rather nice platform for embedded domain specific languages. In particular, they allow an [[EDSL]] to use Haskell's type system for its own purposes. As a simple example, we might have an EDSL for simple (regexplike) parsers that looks something like: 
<haskell> 
<haskell> 

Line 154:  Line 156:  
where allEqual xs = and (zipWith (==) xs (drop 1 xs)) 
where allEqual xs = and (zipWith (==) xs (drop 1 xs)) 

−  evenOdd = Star (Times (Check even) (Check odd)) 
+  evenOdd = Plus (Star (Times (Check even) (Check odd))) 
+  (Star (Times (Check odd) (Check even))) 

+  
</haskell> 
</haskell> 

Line 171:  Line 173:  
*Main> parse blocks "aaaabbbbbbbbcccccddd" 
*Main> parse blocks "aaaabbbbbbbbcccccddd" 

Just ["aaaa","bbbbbbbb","ccccc","ddd"] 
Just ["aaaa","bbbbbbbb","ccccc","ddd"] 

−  *Main> parse evenOdd [ 
+  *Main> parse evenOdd [0..9] 
−  Just [( 
+  Just (Left [(0,1),(2,3),(4,5),(6,7),(8,9)]) 
−  *Main> parse evenOdd [ 
+  *Main> parse evenOdd [1..10] 
−  +  Just (Right [(1,2),(3,4),(5,6),(7,8),(9,10)]) 

+  
</pre> 
</pre> 

⚫  
+  == Projects containing GADTs == 

+  
+  Papers on [[Libraries and tools/Database interfaces/HaskellDBHaskellDB]] describe problems when GADTs can help (but HaskellDB solves these problems with [[phantom type]]s). 

+  
+  [[Darcs]] represents motivating examples for GADTs, too  and uses them. 

+  The motivations are described in David Roundy's FOSDEM slides ([http://physics.oregonstate.edu/~roundyd/talks/fosdem2006.pdf Implementing the Darcs Patch Formalism and Verifying It]) (see p. 11, 1314.). The talk mentions also the notions of [[phantom type]], and [[existential type]], and [[type witness]] (see p. 15). 

+  
+  == See also == 

+  
+  * [[Algebraic data type]] 

+  * [[GADTs for dummies]] 

+  * [http://en.wikibooks.org/wiki/Haskell/GADT The Haskell Wikibook section about GADT] 

+  * [http://apfelmus.nfshost.com/blog/2010/06/01gadtsvideo.html A video that explains GADTs] 

+  
+  
+  [[Category:Glossary]] 

⚫ 
Latest revision as of 22:41, 12 June 2021
The GHC Users Guide has a GADTs section.
Contents
Papers
See also research papers on type systems.
 A short description on generalised algebraic datatypes here as GHC language features.
 Another description with links on the archived Haskell' wiki.
 FirstClass Phantom Types by James Cheney and Ralf Hinze
 Stratified type inference for generalized algebraic data types by François Pottier and Yann RégisGianas. It contains also a lot of links to other papers on GADTs.
 Simple unificationbased type inference for GADTs by Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey Washburn. (Revised April 2006.)
 Translating Generalized Algebraic Data Types to System F written by Martin Sulzmann and Meng Wang. Many other papers. The talk mentions also the notion of phantom type, and existential type, and type witness.
Motivating example
Generalised Algebraic Datatypes (GADTs) are datatypes for which a constructor has a non standard type. Indeed, in type systems incorporating GADTs, there are very few restrictions on the type that the data constructors can take. To show you how this could be useful, we will implement an evaluator for the typed SK calculus. Note that the K combinator is operationally similar to and, similarly, S is similar to the combinator which, in simply typed lambda calculus, have types and Without GADTs we would have to write something like this:
data Term = K  S  Term :@ Term
infixl 6 :@
With GADTs, however, we can have the terms carry around more type information and create more interesting terms, like so:
data Term x where
K :: Term (a > b > a)
S :: Term ((a > b > c) > (a > b) > a > c)
Const :: a > Term a
(:@) :: Term (a > b) > (Term a) > Term b
infixl 6 :@
now we can write a small step evaluator:
eval::Term a > Term a
eval (K :@ x :@ y) = x
eval (S :@ x :@ y :@ z) = x :@ z :@ (y :@ z)
eval x = x
Since the types of the socalled object language, being the typed SK calculus, are mimicked by the type system in our meta language, being Haskell, we have a pretty convincing argument that the evaluator won't mangle our types. We say that typing is preserved under evaluation (preservation.) Note that this is an argument and not a proof.
This, however, comes at a price: let's see what happens when you try to convert strings into our object language:
parse "K" = K
parse "S" = S
you'll get a nasty error like so:
Occurs check: cannot construct the infinite type: c = b > c Expected type: Term ((a > b > c) > (a > b) > a > b > c) Inferred type: Term ((a > b > c) > (a > b) > a > c) In the definition of `foo': foo "S" = S
One could, however, reason that parse has type: String > exists a. Term a
, see also Existential type.
Example with lists
here's another, smaller example:
data Empty
data NonEmpty
data List x y where
Nil :: List a Empty
Cons:: a > List a b > List a NonEmpty
safeHead:: List x NonEmpty > x
safeHead (Cons a b) = a
now safeHead can only be applied to non empty lists, and will never evaluate to bottom. This too comes at a cost; consider the function:
silly 0 = Nil
silly 1 = Cons 1 Nil
yields an objection from ghc:
Couldn't match `Empty' against `NonEmpty' Expected type: List a Empty Inferred type: List a NonEmpty In the application `Cons 1 Nil' In the definition of `silly': silly 1 = Cons 1 Nil
Parsing Example
Note that GADTs provide a rather nice platform for embedded domain specific languages. In particular, they allow an EDSL to use Haskell's type system for its own purposes. As a simple example, we might have an EDSL for simple (regexplike) parsers that looks something like:
data Parser tok a where
Zero :: Parser tok ()
One :: Parser tok ()
Check :: (tok > Bool) > Parser tok tok
Satisfy :: ([tok] > Bool) > Parser tok [tok]
Push :: tok > Parser tok a > Parser tok a
Plus :: Parser tok a > Parser tok b > Parser tok (Either a b)
Times :: Parser tok a > Parser tok b > Parser tok (a,b)
Star :: Parser tok a > Parser tok [a]
An evaluator/parser is then straightforward. Below it's written monadically for convenience, but this also means that we could generalise the return type to being in any MonadPlus. Note that an advantage of this representation which we don't show here is that we could also write a function which applies algebraic rules to the structure to try to simplify the parser before running it. (Though if we were really concerned with efficiency, we'd probably also need a couple more primitives.)
parse :: Parser tok a > [tok] > Maybe a
 Zero always fails.
parse Zero ts = mzero
 One matches only the empty string.
parse One [] = return ()
parse One _ = mzero
 Check p matches a string with exactly one token t such that p t holds.
parse (Check p) [t] = if p t then return t else mzero
parse (Check p) _ = mzero
 Satisfy p any string such that p ts holds.
parse (Satisfy p) xs = if p xs then return xs else mzero
 Push t x matches a string ts when x matches (t:ts).
parse (Push t x) ts = parse x (t:ts)
 Plus x y matches when either x or y does.
parse (Plus x y) ts = liftM Left (parse x ts) `mplus` liftM Right (parse y ts)
 Times x y matches the concatenation of x and y.
parse (Times x y) [] = liftM2 (,) (parse x []) (parse y [])
parse (Times x y) (t:ts) =
parse (Times (Push t x) y) ts `mplus`
liftM2 (,) (parse x []) (parse y (t:ts))
 Star x matches zero or more copies of x.
parse (Star x) [] = return []
parse (Star x) (t:ts) = do
(v,vs) < parse (Times x (Star x)) (t:ts)
return (v:vs)
Finally, we might define some examples:
token x = Check (== x)
string xs = Satisfy (== xs)
p = Times (token 'a') (token 'b')
p1 = Times (Star (token 'a')) (Star (token 'b'))
p2 = Star p1
blocks :: (Eq tok) => Parser tok [[tok]]
blocks = Star (Satisfy allEqual)
where allEqual xs = and (zipWith (==) xs (drop 1 xs))
evenOdd = Plus (Star (Times (Check even) (Check odd)))
(Star (Times (Check odd) (Check even)))
Testing this in ghci:
*Main> parse p "ab" Just ('a','b') *Main> parse p "ac" Nothing *Main> parse p1 "aaabbbb" Just ("aaa","bbbb") *Main> parse p2 "aaabbbbaabbbbbbbaaabbabab" Just [("aaa","bbbb"),("aa","bbbbbbb"),("aaa","bb"),("a","b"),("a","b")] *Main> :t p2 p2 :: Parser Char [([Char], [Char])] *Main> parse blocks "aaaabbbbbbbbcccccddd" Just ["aaaa","bbbbbbbb","ccccc","ddd"] *Main> parse evenOdd [0..9] Just (Left [(0,1),(2,3),(4,5),(6,7),(8,9)]) *Main> parse evenOdd [1..10] Just (Right [(1,2),(3,4),(5,6),(7,8),(9,10)])
Projects containing GADTs
Papers on HaskellDB describe problems when GADTs can help (but HaskellDB solves these problems with phantom types).
Darcs represents motivating examples for GADTs, too  and uses them. The motivations are described in David Roundy's FOSDEM slides (Implementing the Darcs Patch Formalism and Verifying It) (see p. 11, 1314.). The talk mentions also the notions of phantom type, and existential type, and type witness (see p. 15).