310

# Haskell Types Revisited

## Bucharest FP

February 25, 2015

## Transcript

2. ### Type systems “Source code is for humans to read, and

only incidentally for machines to run.” Tools for abstraction Tools for documentation Safeguards against errors

types
4. ### Haskell typing philosophy Strong Static Algebraic “If it passes the

type checker, then it’s correct”
5. ### Primitive types 3 :: Int 120894192912541294198294982 :: Integer 3.14 ::

Float a :: Char "The cake is a lie" :: String True :: Bool
6. ### Basic type constructors data Void data Unit = MkUnit data

Bool = False | True data Kg = MkKg Int -- newtype?
7. ### Canonical types data Pair a b = Pair a b

-- (a, b) data Either a b = Left a | Right b type Maybe a = Either Unit a -- Nothing | Just a data Identity a = Identity a data Const a b = Const a
8. ### Recursive data structures data Nat = Z | S Nat

data List a = Empty | Cons a (List a)
9. ### Digression: type classes class Eq a where (==) :: a

-> a -> Bool instance Eq Bool where True == True = True False == False = True _ == _ = False
10. ### Digression: kinds Types also have types They are called kinds

> :k Bool Bool :: * > :k List List :: * -> * > :k List Int List Int :: * Well-formed typed expressions have the kind *
11. ### Type-level numbers data Z data S n class Card n

where instance Card Z where instance Card n => Card (S n) where
12. ### Fixed-length lists newtype Vector n a = Vector { fromVect

:: List a } Vector constructor is not suﬃcient Use smart constructors
13. ### Fixed-length lists: smart constructors newtype Vector n a = Vector

{ fromVect :: List a } vnil :: Vector Z a vnil = Vector Empty vcons :: Card n => a -> Vector n a -> Vector (S n) a vcons x (Vector xs) = Vector (x Cons xs)
14. ### Fixed-length lists: useful functions head and tail are type safe

vhead :: Card n => Vector (S n) a -> a vhead (Vector (Cons x _)) = x vtail :: Card n => Vector (S n) a -> Vector n a vtail (Vector (Cons _ xs)) = Vector xs
15. ### Fixed-length lists: problems vappend? vappend :: Card n => Vector

n a -> Vector m a -> Vector (n + m) a Type family for Z and S n Undecidable instances
16. ### Conclusion hackage.haskell.org/package/mono-traversable Dependently-typed languages: Idris, Agda, Coq Require (mostly) manual

typechecking!