DouKaku?

val given_list = [1, 2, 3, 4, 5];
app (fn x => print (Int.toString x ^ "\n")) (rev given_list);

String.map Char.toUpper "abc"

fun y f x = f (y f) x

print (CommandLine.name () ^ "\n");

fun check [] = true
  | check (x::xs) = (List.all (fn y => y < x) xs orelse List.all (fn y => y> x) xs) andalso check xs;

(* show path *)
case OS.Process.getEnv "PATH" of
   SOME v => print (v ^ "\n")
 | NONE => print "no path\n"
;

fun addDate (time, sec) = Date.toString (Date.fromTimeLocal (Time.+ (Time.fromSeconds sec, Date.toTime (valOf (Date.fromString time)))));

print (addDate ("Tue Sep 02 10:20:30 2008", 15) ^ "\n");
print (addDate ("Tue Sep 02 10:20:30 2008", ~5) ^ "\n");

print (Int.toString (OS.FileSys.fileSize (hd (CommandLine.arguments ()))) ^ "\n"
         handle _ => "Not found\n");

fun modular (n,l,h) = l + n mod (h-l+1);

fun center s width =
  let
    open StringCvt

    val len = size s
    val m = abs (width - len)
    val (left, right) = (m div 2, m div 2 + m mod 2)
  in
    if width < len then substring (s, left, len - left - right)
    else (padLeft #" " (left + right + len) o padRight #" " (right + len)) s
  end

open Int64

fun collatz n =
  let
    fun f (1, i) = i
      | f (n', i) =
      if n' mod 2 = 0 then f (n' div 2, i + 1)
      else f (n' * 3 + 1, i + 1)

    fun loop 0 max = max
      | loop n max =
      let
        val r = if n mod 2 = 0 then f (n div 2, 1) else f (n * 3 + 1, 1)
      in
        loop (n - 1) (if #2 max > r then max else (n, r))
      end
  in
    loop n (n, 0)
  end

val (n, step) = (collatz o fromLarge o IntInf.pow) (2, 20)
val _ = print ("f(" ^ toString n ^ ") = " ^ toString step ^ "\n")

val name = CommandLine.name ()
val _ = print name
val args = CommandLine.arguments ()
val _ = app print args

functor Modular (val m : int) = struct
  infix 7 *
  infix 6 + -

  local
    fun calc f x y s =
      let
        open Int

        val _ = print (toString x ^ " " ^ s ^ " " ^ toString y ^ " = ")
        val x' = x mod m and y' = y mod m
        val _ = if x >= m orelse y >= m then
                  print (toString x' ^ " " ^ s ^ " " ^ toString y' ^ " = ")
                else ()
        val result = f (x', y') mod m
      in
        print (toString result ^ "\n");
        result
      end
  in
    fun x + y = calc Int.+ x y "+"
    fun x - y = calc Int.- x y "-"
    fun x * y = calc Int.* x y "*"
  end

end

val p = [
   2,  3,  5,  7, 11, 13, 17, 19, 23, 29,
  31, 37, 41, 43, 47, 53, 59, 61, 67, 71
  ] : IntInf.int list

fun basis n = (rev o map (fn x => IntInf.pow (10, x)) o List.tabulate) (n, fn x => x)

fun meertens n = let
  val lst = List.tabulate (n, fn x => x + 1)

  open IntInf

  fun loop _ [] _ prod sum _ =
    if prod = sum then print (toString sum ^ "\n") else ()
    | loop (p::ps) (b::bs) bound prod sum start = let
      fun f x = let
        val pp = pow (p, x)
      in
        if pp <= bound then
          loop ps bs (bound div pp) (prod * pp) (sum + b * fromInt x) 0
        else ()
      end

      open Int
      val lst = List.tabulate (10 - start, fn x => x + start)
    in
      app f lst
    end
in
  app (fn i => loop p (basis i) (IntInf.pow (10, i)) 1 0 1) lst
end

val _ = (meertens o valOf o Int.fromString o hd o CommandLine.arguments) ()

val xs = [3, 1, 4, 1, 5, 9, 2, 6, 5]

fun uniq [] = []
  | uniq (x::xs) =
  if List.exists (fn y => y = x) xs then uniq (List.filter (fn z => z <> x) xs)
  else x :: uniq xs

val _ = uniq xs

fun goedel n = let
  open IntInf

  val p = [
     2,  3,  5,  7, 11, 13, 17, 19, 23, 29,
    31, 37, 41, 43, 47, 53, 59, 61, 67, 71
    ]
  val a = map (valOf o Int.fromString o str) ((explode o toString) n)
in
  ListPair.foldl (fn (x, y, z) => pow (x, y) * z) 1 (p, a)
end

fun meertens n = let
  fun loop i =
    if i > n then ()
    else
      if goedel n = n then (print (IntInf.toString n ^ "\n"); loop (i + 1))
      else loop (i + 1)
  in
    loop 0
  end

val _ = (meertens o valOf o IntInf.fromString o hd o CommandLine.arguments) ()

fun pyramid s =
let
  fun loop s' NONE = []
    | loop s' (SOME c) =
    let
      val ns = subst (str c) "" s'
    in
      loop ns (CharVector.find Char.isGraph ns) @ [s']
    end

  val ss = (String.concatWith " " o global_slice ".") s
in
  (app println o loop ss o SOME o sub) (ss, 0)
end

val _ = pyramid "hoge"
val _ = pyramid "abracadabra"

infix &
fun x & y = x andalso y

fun overlap r1 r2 =
  (#t r1 > #b r2) & (#r r1 < #l r2) & (#b r1 < #t r2) & (#l r1 > #r r2)

fun check filename =
let
  val t = OS.FileSys.modTime filename
in
  (OS.Process.sleep o Time.fromSeconds) 1;

  if t = OS.FileSys.modTime filename then
    check filename
  else
    (print ("modified!" ^ "\n"); check filename)
end

val _ = check "hoge.txt"

fun pyramid n =
let
  open StringCvt

  fun f x = (padLeft #" " (n + x - 1) o padRight #"*" (x * 2 - 1)) ""
in
  (app println o map f o List.tabulate) (n, fn x => x + 1)
end

val _ = pyramid 4