introduction to functional languages
TRANSCRIPT
Logos Island
GuruBluff
Bottomless Methodology
Caves
Cannibals
Temple of theZillionth Feature
PerformanceFalls
Nil Point
Compiler Pass
Ivory Towers
SoftwarePiratesCove
PhDSprings
Mother Lode
BinaryJungle
Vast Typeless TrapsCoral Ref
Electric Sea
Pointer ForestImpenetrable
IO Stream
Sli
ppery
Slopes
Bugg
yBi
ght
Bay of Naïveté
ValleyM
onomorphic
Memory Leaks
Considerable Coast
Criti
calP
ath
+ +
LazySwamp
OptimizationRapids
+
+
+
+ +
+
+
Laptop Beach
+DopedSiliconMines
Intermittent Faults
Data FlowControl Flow
+OpaqueView
Code
Wal
kAudit Trail
+LoopholeLair
Brown-out Current
N
LC93
Z
R Q
+ScopeNest
User
Desert
GreatAd-HocVolcano
AbstractionPeaks
Introduction to Functional Languages
1. Referential transparency, no side effects“substitution of equals for equals”
2. Function definitions can be usedSuppose f is defined to be the function (fn x=>exp), then f(arg) can be replaced by exp[x := arg]
3. Lists not arrays
4. Recursion not iteration
5. Higher-order functionsNew idioms, total procedural abstraction
Rewriting
fun square x = x * x;fun sos (x,y) = (square x) + (square y);
sos (3,4)==> (square 3) + (square 4) [Def’n of sos]==> 3*3 + (square 4) [Def’n of square]==> 9 + (square 4) [Def’n of *]==> 9 + 4*4 [Def’n of square]==> 9 + 16 [Def’n of *]==> 25 [Def’n of +]
Language of expressions only, no statements.
fun test (x) = if x>20 then "big" else "small"
test (sos (3,4))==> test(25)==> if 25>20 then "big" else "small"==> "big"
Canonical Value
Canonical value. A canonical value is one which cannot be rewrittenfurther.For example, 2+3 is not canonical, it evaluates to 5; 5 is a canonicalvalue.See canonical in the “The on-line hacker Jargon File,” version 4.4.7, 29Dec 2003.
History of Functional Languages
1959 LISP: List processing, John McCarthy
1975 Scheme: MIT
1977 FP: John Backus
1980 Hope: Burstall, McQueen, Sannella
1984 COMMON LISP: Guy Steele
1985 ML: meta-language (of LCF), Robin Milner
1986 Miranda: Turner
1990 Haskell: Hudak & Wadler editors
Functional Languages
Lazy: don’t evaluate the function (constructor) arguments until needed(call-by-name), e.g., Haskell. Permits infinite data structures.Eager: call-by-value, e.g., ML
ML and Haskell
I Similar to ML: functional, strongly-typed, algebraic data types,type inferencing
I Differences: no references, exception handling, or side effects ofany kind; lazy evaluation, list comprehensions
Salient Features of Haskell
1. Strongly-typed, lazy, functional language
2. Polymorphic types, type inference
3. Algebraic type definitions
4. Pattern matching function definitions
5. System of classes
6. Interactive
Information about Haskell
O’Sullivan, Goerzen, Stewart Real World Haskell
Hutton, Graham, Programming in Haskell.O’Donnell et al., Discrete Mathematics Using a Computer.
Introduction to SML
1. Robin Milner, Turing Award winner 1991
2. Metalanguage (ML) in Logic of Computable Functions (LCF)1980s
3. Actually general purpose language
4. SML definition 1990, revised 1997.
5. AT&T (D. McQueen), Princeton (A. Appel) implementation
Salient Features of SML
1. Strongly-typed, eager, functional language
2. Polymorphic types, type inference
3. Algebraic type definitions
4. Pattern matching function definitions
5. Exception handling
6. Module (signatures/structures) system
7. Interactive
Information about ML
Ullman, Jeffrey D. Elements of ML Programming. Second edition.Prentice-Hall, Upper Saddle River, New Jersey, 1998. 0-13-790387-1.
Paulson, Lawrence C. ML for the Working Programmer. Secondedition. Cambridge University Press, Cambridge, England, 1996.ISBN 0-521-56543-X.
Haskell
I Similar to ML: functional, strongly-typed, algebraic data types,type inferencing
I Differences: no references, exception handling, or side effects ofany kind; lazy evaluation, list comprehensions
fac n = if n==0 then 1 else n * fac (n-1)
data Tree = Leaf | Node (Tree , String, Tree)
size (Leaf) = 1size (Node (l,_,r)) = size (l) + size (r)
squares = [ n*n | n <- [0..] ]pascal = iterate (\row->zipWith (+) ([0]++row) (row++[0])) [1]
Haskell List Comprehension
[e | x1 <- l1, ..., xm <- lm, P1, ..., Pn]
e is an expression, xi is a variable, li is a list, Pi is a predicate
[ xˆ2 | x <- [ 1..10 ], even x][ xˆ2 | x <- [ 2,4..10 ] ][ x+y | x <- [1..3], y <- [1..4] ]
perms [] = [[]]perms x = [a:y | a<-x, y<-perms (x \\ [a]) ]
quicksort [] = []quicksort (s:xs) =quicksort[x|x<-xs,x<s]++[s]++quicksort[x|x<-xs,x>=s]
Patterns
Patterns are a very natural way of expression complex problems.Consider the code to re-balance red-black trees. This is usually quitecomplex to express in a programming language. But with patterns itcan be more concise. Notice that constructors of user-defined types(line RBTree) as well as pre-defined types (like list) can be used inpatterns.
data Color = R | B deriving (Show, Read)data RBTree a = Empty | T Color (RBTree a) a (RBTree a)deriving (Show, Read)
balance :: RBTree a -> a -> RBTree a -> RBTree abalance (T R a x b) y (T R c z d)=T R (T B a x b) y (T B c z d)balance (T R (T R a x b) y c) z d=T R (T B a x b) y (T B c z d)balance (T R a x (T R b y c)) z d=T R (T B a x b) y (T B c z d)balance a x (T R b y (T R c z d))=T R (T B a x b) y (T B c z d)balance a x (T R (T R b y c) z d)=T R (T B a x b) y (T B c z d)balance a x b = T B a x b
Functions
Prelude> : m Text.Show.FunctionsPrelude Text.Show.Functions > \x->x+1<function >Prelude Text.Show.Functions > :t \x->x+(1::Int)\x->x+(1::Int) :: Int -> IntPrelude Text.Show.Functions > :t \x->x+1\x->x+1 :: (Num a) => a -> a
Partial Application
Any curried function may be called with fewer arguments than it wasdefined for. The result is a function of the remaining arguments.If f is a function Int->Bool->Int->Bool, then
f :: Int->Bool->Int->Boolf 2 :: Bool->Int->Boolf 2 True :: Int->Boolf 2 True 3 :: Bool
Higher-order functions after lists.
Fold
foldr⊗
z[x1,x2, . . . ,xn] = x1
⊗(x2
⊗(. . .(xn
⊗z) . . .))
foldr f z [x1, x2, ..., xn] = x1 f (x2 f (...(xn f z)...))
Fold
foldl⊗
z[x1,x2, . . . ,xn] = (. . .((z⊗
x1)⊗
x2) . . .)⊗
xn
foldl f z [x1, x2, ..., xn] = (...((z f x1) f x2) ... ) f xn
Haskell Fold
foldr :: (b -> a -> a) -> a -> [b] -> afoldr f z [] = zfoldr f z (x:xs) = f x (foldr f z xs)
foldl :: (a -> b -> a) -> a -> [b] -> afoldl f z [] = zfoldl f z (x:xs) = foldl f (f z x) xs
foldl’ :: (a -> b -> a) -> a -> [b] -> afoldl’ f z0 xs = foldr f’ id xs z0
where f’ x k z = k $! f z x
[Real World Haskell says never use foldl instead use foldl’.]
Haskell Fold
Evaluates its first argument to head normal form, and then returns itssecond argument as the result.
seq :: a -> b -> b
Strict (call-by-value) application, defined in terms of ’seq’.
($!) :: (a -> b) -> a -> bf $! x = x ‘seq‘ f x
Haskell Fold
One important thing to note in the presence of lazy, ornormal-order evaluation, is that foldr will immediately returnthe application of f to the recursive case of folding over therest of the list. Thus, if f is able to produce some part of itsresult without reference to the recursive case, and the rest ofthe result is never demanded, then the recursion will stop.This allows right folds to operate on infinite lists. By contrast,foldl will immediately call itself with new parameters until itreaches the end of the list. This tail recursion can beefficiently compiled as a loop, but can’t deal with infinite listsat all – it will recurse forever in an infinite loop.
Haskell Fold
Another technical point to be aware of in the case of leftfolds in a normal-order evaluation language is that the newinitial parameter is not being evaluated before the recursivecall is made. This can lead to stack overflows when onereaches the end of the list and tries to evaluate the resultinggigantic expression. For this reason, such languages oftenprovide a stricter variant of left folding which forces theevaluation of the initial parameter before making therecursive call, in Haskell, this is the foldl’ (note theapostrophe) function in the Data.List library. Combined withthe speed of tail recursion, such folds are very efficient whenlazy evaluation of the final result is impossible orundesirable.
Haskell Fold
sum’ = foldl (+) 0product’ = foldl (*) 1and’ = foldl (&&) Trueor’ = foldl (||) Falseconcat’ = foldl (++) []composel = foldl (.) idcomposer = foldr (.) idlength = foldl (const (+1)) 0list_identity = foldr (:) []reverse’ = foldl (flip (:)) []unions = foldl Set.union Set.empty
Haskell Fold
reverse = foldl (\ xs x -> xs ++ [x]) []map f = foldl (\ xs x -> f x : xs) []filter p = foldl (\ xs x -> if p x then x:xs else xs) []
Haskell Data Structures
data Bool = False | True
data Color = Red | Green | Bluederiving Show
data Day = Mon|Tue|Wed|Thu|Fri|Sat|Sunderiving (Show,Eq,Ord)
Types and constructors capitalized.Show allows Haskell to print data structures.
Haskell Data Structures
Constructors can take arguments.
data Shape = Circle Float | Rectangle Float Floatderiving Show
area (Circle r) = pi*r*rarea (Rectangle s1 s2) = s1*s2
Haskell Classes
next :: (Enum a, Bounded a, Eq a) => a -> anext x | x == maxBound = minBound| otherwise = succ x
Haskell Classes
data Triangle = Triangledata Square = Squaredata Octagon = Octagon
class Shape s wheresides :: s -> Integer
instance Shape Triangle wheresides _ = 3
instance Shape Square wheresides _ = 4
instance Shape Octagon wheresides _ = 8
Haskell Types
Type constructors can type types as parameters.
data Maybe a = Nothing | Just a
maybe :: b -> (a -> b) -> Maybe a -> bmaybe n _ Nothing = nmaybe _ f (Just x) = f x
data Either a b = Left a | Right b
either :: (a -> c) -> (b -> c) -> Either a b -> ceither f _ (Left x) = f xeither _ g (Right y) = g y
Haskell Lists
Data types can be recursive, as in lists:
data Nat = Nil | Succ Natdata IList = Nil | Cons Integer IListdata PolyList a = Nil | Cons a (PolyList a)
Haskell Trees
See Hudak PPT, Ch7.
data SimpleTree = SimLeaf | SimBranch SimpleTree SimpleTreedata IntegerTree = IntLeaf Integer |IntBranch IntegerTree IntegerTreedata InternalTree a = ILeaf |IBranch a (InternalTree a) (InternalTree a)data Tree a = Leaf a | Branch (Tree a) (Tree a)data FancyTree a b = FLeaf a |FBranch b (FancyTree a b) (FancyTree a b)data GTree = GTree [GTree]data GPTree a = GPTree a [GPTree a]
Nested Types
data List a = NilL | ConsL a (List a)data Nest a = NilN | ConsN a (Nest (a,a))data Bush a = NilB | ConsB a (Bush (Bush a))
data Node a = Node2 a a | Node3 a a adata Tree a = Leaf a | Succ (Tree (Node a))
Bird and Meertens, Nested Datatypes, 1998.Hinze, Finger Trees.
Haskell
input stream --> program --> output streamReal World
[Char] --> program --> [Char]Haskell World
module Main where
main = doinput <- getContentsputStr $ unlines $ f $ lines input
countWords :: String -> StringcountWords = unlines . format . count . words
count :: [String] -> [(String,Int)]count = map (\ws->(head ws, length ws)). groupBy (==). sort
Haskell
input stream --> program --> output streamReal World
[Char] --> program --> [Char]Haskell World
module Main where
main = interact countWords
countWords :: String -> StringcountWords = unlines . format . count . words
count :: [String] -> [(String,Int)]count = map (\ws->(head ws, length ws)). groupBy (==). sort