Write You a Haskell Stephen Diehl

Recommendations

Info

[A type system is a] tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute. — Benjamin Pierce Type Systems Type systems are a formal language in which we can describe and restrict the semantics of a programming language. e study of the subject is a rich and open area of research with many degrees of freedom in the design space. As stated in the introduction, this is a very large topic and we are only going to cover enough of it to get through writing the type checker for our language, not the subject in its full generality. e classic text that everyone reads is Types and Programming Languages or ( TAPL ) and discusses the topic more in depth. In fact we will follow TAPL very closely with a bit of a <strong>Haskell</strong> flavor. Rules In the study of programming language semantics, logical statements are written in a specific logical notation. A property, for our purposes, will be a fact about the type of a term. It is written with the following notation: 1 : Nat ese facts exist within a preset universe of discourse called a type system with definitions, properties, conventions, and rules of logical deduction about types and terms. Within a given system, we will have several properties about these terms. For example: • (A1) 0 is a natural number. • (A2) For a natural number n, succ(n) is a natural number. Given several properties about natural numbers, we’ll use a notation that will allow us to chain them together to form proofs about arbitrary terms in our system. 0 : Nat n : Nat succ(n) : Nat (A1) (A2) 54
In this notation, the expression above the line is called the antecedent, and expression below the line is called the conclusion. A rule with no antecedent is an axiom. e variable n is metavariable standing for any natural number, an instance of a rule is a substitution of values for these metavariables. A derivation is a tree of rules of finite depth. We write ⊢ C to indicate that there exists a derivation whose conclusion is C, that C is provable. For example ⊢ 2 : Nat by the derivation: 0 : Nat (A1) succ(0) : Nat (A2) succ(succ(0)) : Nat (A2) Also present in these derivations may be a typing context or typing environment written as Γ. e context is a sequence of named variables mapped to properties about the named variable. e comma operator for the context extends Γ by adding a new property on the right of the existing set. e empty context is denoted ∅ and is the terminal element in this chain of properties that carries no information. So contexts are defined by: Γ ::= ∅ Γ, x : τ Here is an example for a typing rule for addition using contexts: Γ ⊢ e 1 : Nat Γ ⊢ e 2 : Nat Γ ⊢ e 1 + e 2 : Nat In the case where the property is always implied regardless of the context we will shorten the expression. is is just a lexical convention. ∅ ⊢ P := ⊢ P Type Safety In the context of modeling the semantics of programming languages using this logical notation, we often refer to two fundamental categories of rules of the semantics. • Statics : Semantic descriptions which are derived from the syntax of the language. • Dynamics : Semantics descriptions which describe the value evolution resulting from a program. Type safety is defined to be the equivalence between the statics and the dynamics of the language. is equivalence is modeled by two properties that relate the types and evaluation semantics: • Progress : If an expression is well typed then either it is a value, or it can be further evaluated by an available evaluation rule. • Preservation : If an expression e has type τ, and is evaluated to e ′ , then e ′ has type τ. 55
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: parensIf :: Bool -> Doc -> Doc pare
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 and 86: Γ, x : τ = (Γ\x) ∪ {x : τ} Op
Page 87 and 88: where s’ = foldr Map.delete s as
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?