Lecture 014

matcher: 'a -> 'b -> bool
ACCEPT: matcher
REJECT: matcher
CHECK_FOR: char -> matcher
THEN: matcher * matcher -> matcher
ORELSE: matcher * matcher -> matcher
REPEAT: matcher -> matcher

val REJECT = fn cs => fn k => false
val ACCEPT = fn cs => fn k => k cs

fun CHECK_FOR a = fn cs => fn k -> (case cs of [] => false | c::cs' => a = c and k cs')

fun THEN (m1, m2) cs k = ml cs (fn cs' => m2 cs' k)
fun ORELSE (m1, m2) cs k = ml cs k orelse m2 cs k

fun REPEAT m cs k = k cs orelse m cs (fn cs' => cs <> cs' andalso REPEAT m cs' k)

Implementing match

(*match: regexp -> matcher*)
fun match (Char a) = CHECK_FOR a
  | match One = ACCEPT
  | match Zero = REJECT
  | match (Times (r1, r2)) = THEN (match r1, match r2)
  | match (Plus (r1, r2)) = ORELSE (match r1, match r2)
  | match (Star r) = REPEAT (match r)

(*accept: regexp -> string -> bool*)
fun accept r: string -> bool
  = let val m = match r
    in fun s => m (String.explode s) List.null
    end

val f = accept (regexp)

Search using Regexp

success continuation that takes failure as an argument -> give success continuation ability to fail

(*find: int tree -> (int -> (unit -> 'a) -> 'a) -> (init -> 'a) -> 'a*)

fun find Empty sk fk = fk ()
  | find (Node (l, x, r)) sk fk = (let
    fun fcnew () = find l sk (fn () => find r sk fk)
  in
    if x mod 2 = 0 then sk x fcnew else fcnew ()
  end)

fun findone T = find T (fn x => fn _ => SOME x) (fn () => NONE)
fun findall T = find T (fn x => fn f => x::f) (fn () => [])
fun count T = find T (fn _ => fn f => 1 + f()) (fn () => 0)