some additional functionality needed by shwestrick/parse-sml

Author: shwestrick

doc/CommandLineArgs.md

@@ -25,6 +25,17 @@ For reals, this uses `Real.fromString`.
 
 For bools, the value must be either `true` or `false`.
 
+
+```sml
+val parseStrings: string -> string list
+```
+
+`parseStrings key` looks for every `-<key> <value>`  in the command-line
+arguments and returns a list all such `<value>` found.
+
+For example, if `-arg a -arg b -arg c -arg d` is passed at the command line,
+then `parseStrings "arg"` returns `["a", "b", "c", "d"]`.
+
 ```sml
 val parseFlag: string -> bool
 ```

doc/Seq.md

@@ -123,6 +123,14 @@ Converts a list into a sequence.
 Linear work and span.
 
 
+```sml
+val fromRevList: 'a list -> 'a seq
+```
+
+Reverse a list and convert it into a sequence.
+Linear work and span.
+
+
 ```sml
 val toList: 'a seq -> 'a list
 ```

lib/github.com/mpllang/mpllib/ArraySequence.sml

@@ -98,6 +98,10 @@ struct
     tabulate (fn i => nth s (length s - 1 - i)) (length s)
 
 
+  (** TODO: make faster *)
+  fun fromRevList list = rev (fromList list)
+
+
   fun append (s, t) =
     let
       val (ns, nt) = (length s, length t)
@@ -133,16 +137,16 @@ struct
 
 
   fun iteratePrefixes f b s =
-    let 
+    let
       val prefixes = alloc (length s)
-      fun g ((i, b), a) = 
-        let 
+      fun g ((i, b), a) =
+        let
           val _ = A.update (prefixes, i, b)
         in
           (i+1, f (b, a))
         end
       val (_, r) = iterate g (0, b) s
-    in 
+    in
         (AS.full prefixes, r)
     end
 
@@ -173,7 +177,7 @@ struct
     (* Assumes that the predicate p is pure *)
     AS.full (SeqBasis.filter GRAN (0, length s) (nth s) (p o nth s))
 
-  fun filterSafe p s = 
+  fun filterSafe p s =
     (* Does not assume that the predicate p is pure *)
     AS.full (SeqBasis.tabFilter GRAN (0, length s) (fn i => if p (nth s i) then SOME (nth s i) else NONE))
 

lib/github.com/mpllang/mpllib/CommandLineArgs.sml

@@ -7,6 +7,14 @@ sig
   val parseReal: string -> real -> real
   val parseBool: string -> bool -> bool
 
+  (** Look for every instance of -K V and return seq of the Vs.
+    * For example, if this is given on the commandline:
+    *   -arg a -arg b -arg c -arg d
+    * then
+    *   parseStrings "arg" ==> ["a", "b", "c", "d"]
+    *)
+  val parseStrings: string -> string list
+
   (* parseFlag K returns true if --K given on command-line *)
   val parseFlag: string -> bool
 
@@ -51,6 +59,17 @@ struct
     | SOME [] => die ("Missing argument of \"-" ^ key ^ "\" ")
     | SOME (s :: _) => s
 
+  fun parseStrings key =
+    let
+      fun loop args =
+        case search ("-" ^ key) args of
+          NONE => []
+        | SOME [] => die ("Missing argument of \"-" ^ key ^ "\"")
+        | SOME (v :: args') => v :: loop args'
+    in
+      loop (CommandLine.arguments ())
+    end
+
   fun parseInt key default =
     case search ("-" ^ key) (CommandLine.arguments ()) of
       NONE => default

lib/github.com/mpllang/mpllib/Util.sml

@@ -43,11 +43,17 @@ sig
    * for lo <= i < hi, iteratively do  b = f (b, i)  *)
   val loop: (int * int) -> 'a -> ('a * int -> 'a) -> 'a
 
+  val all: (int * int) -> (int -> bool) -> bool
+  val exists: (int * int) -> (int -> bool) -> bool
+
   val copyListIntoArray: 'a list -> 'a array -> int -> int
 
   val revMap: ('a -> 'b) -> 'a list -> 'b list
 
   val intToString: int -> string
+
+  val equalLists: ('a * 'a -> bool) -> 'a list * 'a list -> bool
+
 end =
 struct
 
@@ -138,6 +144,22 @@ struct
     ForkJoin.parfor 4096 (0, ArraySlice.length s)
     (fn i => f (i, ArraySlice.sub (s, i)))
 
+  fun all (lo, hi) f =
+    let
+      fun allFrom i =
+        (i >= hi) orelse (f i andalso allFrom (i+1))
+    in
+      allFrom lo
+    end
+
+  fun exists (lo, hi) f =
+    let
+      fun existsFrom i =
+        i < hi andalso (f i orelse existsFrom (i+1))
+    in
+      existsFrom lo
+    end
+
   fun copyListIntoArray xs arr i =
     case xs of
       [] => i
@@ -323,4 +345,10 @@ struct
           toInt v
         end)
 
+
+  fun equalLists eq ([], []) = true
+    | equalLists eq (x :: xs, y :: ys) =
+        eq (x, y) andalso equalLists eq (xs, ys)
+    | equalLists _ _ = false
+
 end