fun sum nil = 0
| sum(h::t) = h + sum t;

fun doublist nil = nil
| doublist(h::t) = 2*h :: doublist t;

fun len nil = 0
| len(h::t) = 1 + len t;

fun triplist nil = nil
| triplist(h::t) = 3*h :: triplist t;

fun duplist nil = nil
| duplist(h::t) = h :: h :: duplist t;

fun prodlist nil = 1
| prodlist(h::t) = h * prodlist t;

fun rev nil = nil
| rev(h::t) = (rev t) @ [h];

fun space nil = nil
| space(h::t) = [h, " "] @ (space t);

fun flatten nil = nil
| flatten (h::t) = h @ (flatten t);

fun count_ nil = 0
| count_ (1::t) = 1 + count_ t
| count_ (h::t) = count_ t;

fun timeslist x nil = nil
| timeslist x (h::t) = x * h :: timeslist x t;

(*
fun last_h x nil = x
| last_h x (h::t) = last_h h t;

fun last (h::t) = last_h h t;
*)

fun last [h] = h
| last (h::t) = last t;

fun member (x, nil) = false
| member (x, (h::t)) = if (x = h) then true else member (x, t);

fun vallist nil = nil
| vallist (h::t) = ord h - ord #"0" :: vallist t;

(*################################################################################################*)

fun index(0, h::t) = h
| index(n, h::t) = index(n-1, t);

fun takeN(0, h::t) = nil
| takeN(n, h::t) = h :: takeN(n-1, t);

fun dropN(0, x) = x
| dropN(n, h::t) = dropN(n-1,t);

fun insert (n:int) nil = [n]
| insert n (h::t) = if (n<h) then n::h::t
                             else h::(insert n t);
fun sort nil = nil
| sort (h::t) = insert h (sort t);

fun upto x y = if (x = y) then [x] else x::(upto (x + 1) y);

fun dropSpace nil = nil
| dropSpace(h::t) = if (h= #" ") then dropSpace t else h::t;

fun takeSpace nil = nil
| takeSpace (h::t)= if (h= #" ") then h::takeSpace(t) else nil;

fun dropNonSpace nil = nil
| dropNonSpace(h::t) = if (h <> #" ") then dropNonSpace(t) else h::t;

fun takeNonSpace nil = nil
| takeNonSpace (h::t)= if (h <> #" ") then h::takeNonSpace(t) else nil;

fun firstWord x = takeNonSpace(x);

fun butFirstWord x = dropSpace(dropNonSpace(x));

(*################################################################################################*)

fun map f nil = nil
| map f (h::t) = (f h)::map f t;
fun reduce f b nil = b
| reduce f b (h::t) = f(h,reduce f b t);
fun filter f nil = nil
| filter f (h::t) = if f h then h::filter f t else filter f t;

fun member x nil = false
| member x (h::t) = x=h orelse member x t;

fun zip f nil nil = nil
| zip f (h::t) (i::s) = f(h,i)::zip f t s;

fun fst(a,_) = a; (* Also try #1 *)
fun snd(_,b) = b; (* Try #2 *)

val ftrl = map (fn x => 3 * x);

val fhel = map (hd o explode);

val fttl = map (implode o tl o tl o explode);

val fsml = map (fn x => implode(#"s"::(explode x) @ [#"m"] ));

val r = reduce (fn(a:int,b:int list)=>b@[a]:int list) nil;
val p = reduce (op ::);
val dr = reduce (fn(a,b)=>a+10*b) 0;
fun m x = reduce (fn(a,b)=>(a=x) orelse b) false;
fun n x = reduce (fn(a,b)=>(a=x) andalso b) true;
val im = reduce (op ^) "";
val ts = reduce (fn(a,b)=>if a=" " then nil else a::b) nil;