Write You a Haskell Stephen Diehl

Recommendations

Info

[x/e ′ ]x = e ′ [x/e ′ ]y = y (y ≠ x) [x/e ′ ](e 1 e 2 ) = ([x/e ′ ] e 1 )([x/e ′ ]e 2 ) [x/e ′ ](λy.e 1 ) = λy.[x/e ′ ]e y ≠ x, x /∈ fv(e ′ ) And likewise, substitutions can be applied element wise over the typing environment. [t/s]Γ = {y : [t/s]σ | y : σ ∈ Γ} Our implementation of a substitution in <strong>Haskell</strong> is simply a Map from type variables to types. type Subst = Map.Map TVar Type Composition of substitutions ( s 1 ◦ s 2 , s1 ‘compose‘ s2 ) can be encoded simply as operations over the underlying map. Importantly note that in our implementation we have chosen the substitution to be left-biased, it is up to the implementation of the inference algorithm to ensure that clashes do not occur between substitutions. nullSubst :: Subst nullSubst = Map.empty compose :: Subst -> Subst -> Subst s1 ‘compose‘ s2 = Map.map (apply s1) s2 ‘Map.union‘ s1 e implementation in <strong>Haskell</strong> is via a series of implementations of a Substitutable typeclass which exposes the apply which applies the substitution given over the structure of the type replacing type variables as specified. class Substitutable a where apply :: Subst -> a -> a ftv :: a -> Set.Set TVar instance Substitutable Type where apply _ (TCon a) = TCon a apply s t@(TVar a) = Map.findWithDefault t a s apply s (t1 ‘TArr‘ t2) = apply s t1 ‘TArr‘ apply s t2 ftv TCon{} = Set.empty ftv (TVar a) = Set.singleton a ftv (t1 ‘TArr‘ t2) = ftv t1 ‘Set.union‘ ftv t2 instance Substitutable Scheme where apply s (Forall as t) = Forall as $ apply s’ t 84
where s’ = foldr Map.delete s as ftv (Forall as t) = ftv t ‘Set.difference‘ Set.fromList as instance Substitutable a => Substitutable [a] where apply = fmap . apply ftv = foldr (Set.union . ftv) Set.empty instance Substitutable TypeEnv where apply s (TypeEnv env) = TypeEnv $ Map.map (apply s) env ftv (TypeEnv env) = ftv $ Map.elems env roughout both the typing rules and substitutions we will require a fresh supply of names. In this naive version we will simply use an infinite list of strings and slice into n’th element of list per a index that we hold in a State monad. is is a simplest implementation possible, and later we will adapt this name generation technique to be more robust. letters :: [String] letters = [1..] >>= flip replicateM [’a’..’z’] fresh :: Infer Type fresh = do s
Page 1 and 2:
Write You a Haskell Building a mode
Page 3 and 4:
Contents Introduction 6 Goals . . .
Page 5 and 6:
Evaluation . . . . . . . . . . . .
Page 7 and 8:
Syntax Errors . . . . . . . . . . .
Page 9 and 10:
• containers • unordered-contai
Page 11 and 12:
File ””, line 1, in TypeError:
Page 13 and 14:
] TokenSym ”x”, TokenAdd, Token
Page 15 and 16:
f: mov res, arg add res, 1 ret defi
Page 17 and 18:
Datatypes Constructors for datatype
Page 19 and 20:
length :: [a] -> Int length [] = 0
Page 21 and 22:
Higher-Kinded Types e “type of ty
Page 23 and 24:
eturn a >>= f = f a Law 2 m >>= ret
Page 25 and 26:
data PlatonicSolid = Tetrahedron |
Page 27 and 28:
foo :: Stack () foo = Stack $ do pu
Page 29 and 30:
, bar :: Int } deriving (Show) comp
Page 31 and 32:
class IsString a where fromString :
Page 33 and 34:
Parsing Parser Combinators For pars
Page 35 and 36: instance Monad Parser where return
Page 37 and 38: natural :: Parser Integer natural =
Page 39 and 40: print $ eval $ run a Now we can try
Page 41 and 42: module Syntax where data Expr = Tr
Page 43 and 44: cannot proceed because the reductio
Page 45 and 46: later into native CPU instructions
Page 47 and 48: λx.e ere are several syntactical c
Page 49 and 50: type Name = String data Expr = Var
Page 51 and 52: Eta-expansion (λx.ex)e ′ β →
Page 53 and 54: Y = SSK(S(K(SS(S(SSK))))K) In a unt
Page 55 and 56: parensIf :: Bool -> Doc -> Doc pare
Page 57 and 58: In this notation, the expression ab
Page 59 and 60: In all the languages which we will
Page 61 and 62: eval1 expr = case expr of Succ t ->
Page 63 and 64: TNat -> return TNat _ -> throwError
Page 65 and 66: • T-Var Variables are simply pull
Page 67 and 68: t1 throwError $ Mismatch t2 a ty -
Page 69 and 70: Full Source • Typed Arithmetic
Page 71 and 72: 1. Evaluate f to λy.e 2. Evaluate
Page 73 and 74: e 1 → e ′ 1 e 1 e 2 → e ′ 1
Page 75 and 76: case we will use a GADT to embed a
Page 77 and 78: AppP (AppP (VarP f) (VarP x)) (AppP
Page 79 and 80: e prim function will simply perform
Page 81 and 82: ere is nothing more practical than
Page 83 and 84: As before let rec expressions will
Page 85: Γ, x : τ = (Γ\x) ∪ {x : τ} Op
Page 89 and 90: s2 Type -> Infer Subst bind a t |
Page 91 and 92: infer :: TypeEnv -> Expr -> Infer (
Page 93 and 94: App e1 e2 -> do tv
Page 95 and 96: -- | Unify two types uni :: Type ->
Page 97 and 98: unifies t (TVar v) = v ‘bind‘ t
Page 99 and 100: Interpreter Our evaluator will oper
Page 101 and 102: Our language can be compiled into a
Page 103 and 104: exec True contents -- :type command
Page 105 and 106: let rec fib n = if (n == 0) then 0
Page 107 and 108: • Higher order functions • Para
Page 109 and 110: • e PHOAS, the type-erased Core i
Page 111 and 112: If the ProtoHaskell compiler is inv
Page 113 and 114: infixl 6 + infixl 7 * f = 1 + 2 * 3
Page 115 and 116: -- Desugared f x = case x of Just _
Page 117 and 118: data Kind = KStar | KArr Kind Kind
Page 119 and 120: TypeError) -- | Inference state dat
Page 121 and 122: e expression or Expr type is the co
Page 123 and 124: data qname [var] where [tydecl] dat
Page 125 and 126: Typeclass Declarations Typeclass de
Page 127 and 128: Syntax Name Kind Description (,) Pa
Page 129 and 130: So for instance if we have three AS
Page 131 and 132: -- **Begin Haskell Syntax** { {-# O
Page 133 and 134: tokens :- -- Whitespace insensitive
Page 135 and 136: Expr : let VAR ’=’ Expr in Expr
Page 137 and 138:
data Type = TVar Loc TVar | TCon Lo
Page 139 and 140:
-- Start of layout ( Column: 0 ) fi
Page 141 and 142:
Extensible Operators Haskell famous
Page 143 and 144:
fixityspec :: Parser FixitySpec fix
show all

Write You a Haskell Stephen Diehl

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?