Write You a Haskell Stephen Diehl

Recommendations

Info

(:) = Cons [] = Nil (1 : (2 : (3 : []))) = [1,2,3] A tuple is a heterogeneous product type parameterized over the types of its two values. Tuples also have special value-level syntax. data Pair a b = Pair a b a = (1,2) a = Pair 1 2 (,) = Pair Tuples are allowed (with compiler support) to have up to 15 fields in GHC. Pattern matching Pattern matching allows us to discriminate on the constructors of a datatype, mapping separate cases to separate code paths. data Maybe a = Nothing | Just a maybe :: b -> (a -> b) -> Maybe a -> b maybe n f Nothing = n maybe n f (Just a) = f a Top-level pattern matches can always be written identically as case statements. maybe :: b -> (a -> b) -> Maybe a -> b maybe n f x = case x of Nothing -> n Just a -> f a Wildcards can be placed for patterns where the resulting value is not used. const :: a -> b -> a const x _ = x List and tuples have special pattern syntax. 16
length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) fst :: (a, b) -> a fst (a,b) = a Patterns may be guarded by predicates (functions which yield a boolean). Guards only allow the execution of a branch if the corresponding predicate yields True. filter :: (a -> Bool) -> [a] -> [a] filter pred [] = [] filter pred (x:xs) | pred x = x : filter pred xs | otherwise = filter pred xs Recursion In Haskell all iteration over data structures is performed by recursion. Entering a function in Haskell does not create a new stack frame, the logic of the function is simply entered with the arguments on the stack and yields result to the register. In the case where a function returns an invocation of itself invoked in the tail position the resulting logic is compiled identically to while loops in other languages, via a jmp instruction instead of a call. sum :: [Int] -> [Int] sum ys = go ys 0 where go (x:xs) i = go xs (i+x) go [] i = i Functions can be defined to recurse mutually on each other. even 0 = True even n = odd (n-1) odd 0 = False odd n = even (n-1) Laziness A Haskell program can be thought of as being equivalent to a large directed graph. Each edge represents the use of a value, and each node is the source of a value. A node can be: 17
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: Datatypes Constructors for datatype
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 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?