代码
(* Coursera Programming Languages, Homework 3, Provided Code *)
exception NoAnswer
datatype pattern = Wildcard
| Variable of string
| UnitP
| ConstP of int
| TupleP of pattern list
| ConstructorP of string * pattern
datatype valu = Const of int
| Unit
| Tuple of valu list
| Constructor of string * valu
fun g f1 f2 p =
let
val r = g f1 f2
in
case p of
Wildcard => f1 ()
| Variable x => f2 x
| TupleP ps => List.foldl (fn (p,i) => (r p) + i) 0 ps
| ConstructorP(_,p) => r p
| _ => 0
end
(**** for the challenge problem only ****)
datatype typ = Anything
| UnitT
| IntT
| TupleT of typ list
| Datatype of string
(**** you can put all your code here ****)
(*val is closure fun is function*)
(*1*)
val only_capitals = List.filter (fn x => (Char.isUpper o String.sub)(x,0))
(*2*)
val longest_string1 = foldl (fn (acc,x) => if String.size acc > String.size x then acc else x) ""
(*3*)
val longest_string2 = foldl (fn (acc,x) => if String.size acc >= String.size x then acc else x) ""
(*4*)
fun longest_string_helper cmp = foldl (fn (x,y) => if cmp(String.size x,String.size y) then x else y) ""
val longest_string3 = longest_string_helper (fn (x,y) => x > y)
val longest_string4 = longest_string_helper (fn (x,y) => x >= y)
(*5*)
val longest_capitalized = longest_string1 o only_capitals
(*6*)
val rev_string = implode o List.rev o explode
(*7*) (*if we can find it then stop else recursive*)
fun first_answer f lt =
case lt of
[] => raise NoAnswer
| head::tail => case f head of SOME v => v
| NONE => first_answer f tail
(*8*)
(*
fun all_answers f lt =
let
val new = foldl (fn (x,y) => case f x of SOME v => v @ y | NONE => y) [] lt
in
if length new <> length lt then NONE else SOME new
end
*)
fun all_answers f xs =
let fun loop (acc,xs) =
case xs of
[] => SOME acc
| x::xs' => case f x of
NONE => NONE
| SOME y => loop((y @ acc), xs')
in loop ([],xs) end
(*9a*)
val count_wildcards = g (fn () => 1) (fn x => 0)
(*9b*)
val count_wild_and_variable_lengths = g (fn () => 1) (fn x => String.size x)
(*9c*)
fun count_some_var (st,p) = g (fn () => 0) (fn x => if st = x then 1 else 0) p
(*10*)
val check_pat =
let
fun coll inn_p =
case inn_p of
Variable x => [x]
| TupleP ps => foldl (fn (x,y) => (coll x) @ y) [] ps (***********)
| ConstructorP(_,np) => coll np
| _ => []
fun isrep sl =
case sl of
[] => false
| head::tail => List.exists (fn x:string => x = head) tail orelse isrep tail
in
not o isrep o coll
end
(*11*)
fun match vandp =
case vandp of
(va,Variable s) => SOME [(s,va)]
| (Const i1,ConstP i2) => if i1 = i2 then SOME [] else NONE
| (Unit,UnitP) => SOME []
| (Tuple vs,TupleP ps) => if length vs = length ps then (all_answers match (ListPair.zip(vs,ps))) else NONE
| (Constructor(s1:string,v),ConstructorP(s2,p)) => if s1 = s2 then match(v,p) else NONE
| (_,Wildcard) => SOME []
| _ => NONE
(*12*)
fun first_match v ps= SOME (first_answer (fn p => match(v,p)) ps) handle NoAnswer => NONE
知识点
First-Class Function
就是函数可以当做数据来传入一个函数或者作为函数的返回值
匿名函数
真是个好东西
词法作用域
词法作用域就是函数调用时所使用的环境为函数定义时所使用的环境
闭包
闭包就是一种数据,它包括代码和该函数所处作用域数据的绑定
Combining Fuction
通过 o 操作符来组合函数,避免函数嵌套,代码更加优雅
map filter fold
currying
将多参函数转换成单参函数的技术
Partial Application
提高代码的复用率
如何使用函数式编程实现ADT
实现一个集合
Mutable 和 callback
用val绑定函数和用fun绑定函数的区别是前者不能处理递归情况后者可以
val绑定一个函数,如果必须在绑定时传一个参数那么得用fun绑定