initial work on flattening all immutable tuples into sequence containers

basis-library/arrays-and-vectors/array-flat-slice.sig

@@ -0,0 +1,48 @@
+signature ARRAY_FLAT_SLICE =
+sig
+  type 'a slice
+
+  val all: ('a -> bool) -> 'a slice -> bool
+  val app : ('a -> unit) -> 'a slice -> unit
+  val appi: (int * 'a -> unit) -> 'a slice -> unit
+  val base: 'a slice -> 'a ArrayFlat.t * int * int
+  val collate: ('a * 'a -> order) -> 'a slice * 'a slice -> order
+  val copy: {dst: 'a ArrayFlat.t, di: int, src: 'a slice} -> unit
+  val copyVec: {dst: 'a ArrayFlat.t, di: int, src: 'a VectorFlatSlice.slice} -> unit
+  val exists: ('a -> bool) -> 'a slice -> bool
+  val find: ('a -> bool) -> 'a slice -> 'a option
+  val findi: (int * 'a -> bool) -> 'a slice -> (int * 'a) option
+  val foldl: ('a * 'b -> 'b) -> 'b -> 'a slice -> 'b
+  val foldli: (int * 'a * 'b -> 'b) -> 'b -> 'a slice -> 'b
+  val foldr: ('a * 'b -> 'b) -> 'b -> 'a slice -> 'b
+  val foldri: (int * 'a * 'b -> 'b) -> 'b -> 'a slice -> 'b
+  val full: 'a ArrayFlat.t -> 'a slice
+  val getItem: 'a slice -> ('a * 'a slice) option
+  val isEmpty: 'a slice -> bool
+  val length: 'a slice -> int
+  val modify : ('a -> 'a) -> 'a slice -> unit
+  val modifyi: (int * 'a -> 'a) -> 'a slice -> unit
+  val slice: 'a ArrayFlat.t * int * int option -> 'a slice
+  val sub: 'a slice * int -> 'a
+  val subslice: 'a slice * int * int option -> 'a slice
+  val update: 'a slice * int * 'a -> unit
+  val vector: 'a slice -> 'a VectorFlat.vector
+end
+
+signature ARRAY_FLAT_SLICE_EXTRA =
+sig
+  include ARRAY_FLAT_SLICE
+
+  val uninitIsNop: 'a slice -> bool
+  val uninit: 'a slice * int -> unit
+  val unsafeSub: 'a slice * int -> 'a
+  val unsafeCopy: {dst: 'a ArrayFlat.t, di: int, src: 'a slice} -> unit
+  val unsafeCopyVec: {dst: 'a ArrayFlat.t, di: int, src: 'a VectorFlatSlice.slice} -> unit
+  val unsafeSlice: 'a ArrayFlat.t * int * int option -> 'a slice
+  val unsafeSubslice: 'a slice * int * int option -> 'a slice
+  val unsafeUninit: 'a slice * int -> unit
+  val unsafeUpdate: 'a slice * int * 'a -> unit
+
+  val concat: 'a slice list -> 'a ArrayFlat.t
+  val toList: 'a slice -> 'a list
+end

basis-library/arrays-and-vectors/array-flat.sig

@@ -0,0 +1,65 @@
+signature ARRAY_FLAT =
+sig
+  type 'a array = 'a ArrayFlat.t
+  type 'a vector = 'a VectorFlat.vector
+
+  val all: ('a -> bool) -> 'a array -> bool
+  val app: ('a -> unit) -> 'a array -> unit 
+  val appi: (int * 'a -> unit) -> 'a array -> unit 
+  val array: int * 'a -> 'a array 
+  val collate: ('a * 'a -> order) -> 'a array * 'a array -> order
+  val copy: {src: 'a array, dst: 'a array, di: int} -> unit 
+  val copyVec: {src: 'a vector, dst: 'a array, di: int} -> unit 
+  val exists: ('a -> bool) -> 'a array -> bool
+  val find: ('a -> bool) -> 'a array -> 'a option
+  val findi: (int * 'a -> bool) -> 'a array -> (int * 'a) option
+  val foldl: ('a * 'b -> 'b) -> 'b -> 'a array -> 'b 
+  val foldli: (int * 'a * 'b -> 'b) -> 'b -> 'a array -> 'b
+  val foldr: ('a * 'b -> 'b) -> 'b -> 'a array -> 'b 
+  val foldri: (int * 'a * 'b -> 'b) -> 'b -> 'a array -> 'b
+  val fromList: 'a list -> 'a array 
+  val length: 'a array -> int 
+  val maxLen: int 
+  val modify: ('a -> 'a) -> 'a array -> unit 
+  val modifyi: (int * 'a -> 'a) -> 'a array -> unit 
+  val sub: 'a array * int -> 'a 
+  val tabulate: int * (int -> 'a) -> 'a array 
+  val update: 'a array * int * 'a -> unit 
+  val vector: 'a array -> 'a vector
+end
+
+signature ARRAY_FLAT_EXTRA =
+sig
+  include ARRAY_FLAT
+
+  structure ArraySlice: ARRAY_FLAT_SLICE_EXTRA 
+
+  val alloc: int -> 'a array
+  val uninitIsNop: 'a array -> bool
+  val uninit: 'a array * int -> unit
+  val unsafeAlloc: int -> 'a array
+  val unsafeArray: int * 'a -> 'a array
+  val unsafeCopy: {dst: 'a array, di: int, src: 'a array} -> unit
+  val unsafeCopyVec: {dst: 'a array, di: int, src: 'a vector} -> unit
+  val unsafeSub: 'a array * int -> 'a
+  val unsafeUninit: 'a array * int -> unit
+  val unsafeUpdate: 'a array * int * 'a -> unit
+
+  val concat: 'a array list -> 'a array
+  val duplicate: 'a array -> 'a array
+  val toList: 'a array -> 'a list
+  val unfoldi: int * 'b * (int * 'b -> 'a * 'b) -> 'a array * 'b
+  val unfold: int * 'b * ('b -> 'a * 'b) -> 'a array * 'b
+
+  structure Raw:
+      sig
+        type 'a rawarr
+        val alloc: int -> 'a rawarr
+        val length: 'a rawarr -> int
+        val uninit: 'a rawarr * int -> unit
+        val uninitIsNop: 'a rawarr -> bool
+        val unsafeAlloc: int -> 'a rawarr
+        val unsafeToArray: 'a rawarr -> 'a array
+        val unsafeUninit: 'a rawarr * int -> unit
+      end
+end

basis-library/arrays-and-vectors/array-flat.sml

@@ -0,0 +1,63 @@
+structure ArrayFlat: ARRAY_FLAT_EXTRA =
+struct
+  structure A = Sequence (Primitive.ArrayFlat)
+  open A
+
+  val op < = Int.<
+  val op <= = Int.<=
+
+  fun wrap2 f = fn (i, x) => f (SeqIndex.toIntUnsafe i, x)
+
+  type 'a array = 'a ArrayFlat.t
+  type 'a vector = 'a VectorFlat.vector
+
+  structure ArraySlice =
+  struct
+    open Slice
+    val vector = Primitive.ArrayFlat.Slice.vector
+    val copyVec = VectorFlat.VectorSlice.copy
+    val unsafeCopyVec = VectorFlat.VectorSlice.unsafeCopy
+    fun modifyi f sl = Primitive.ArrayFlat.Slice.modifyi (wrap2 f) sl
+    val modify = Primitive.ArrayFlat.Slice.modify
+  end
+
+  val array = new
+  val unsafeArray = unsafeNew
+  val vector = Primitive.ArrayFlat.vector
+  val copyVec = VectorFlat.copy
+  val unsafeCopyVec = VectorFlat.unsafeCopy
+  fun modifyi f sl = Primitive.ArrayFlat.modifyi (wrap2 f) sl
+  val modify = Primitive.ArrayFlat.modify
+  structure Raw = Primitive.ArrayFlat.Raw
+  structure Raw =
+  struct
+    type 'a rawarr = 'a Raw.rawarr
+
+    fun length a =
+        if Primitive.Controls.safe
+          then (SeqIndex.toInt (Raw.length a))
+                handle Overflow => raise Fail "Raw.length"
+          else SeqIndex.toIntUnsafe (Raw.length a)
+
+    fun alloc n = Raw.alloc (SeqIndex.fromIntForLength n)
+    fun unsafeAlloc n = Raw.unsafeAlloc (SeqIndex.fromIntUnsafe n)
+
+    val uninitIsNop = Raw.uninitIsNop
+    fun unsafeUninit (a, i) =
+        Raw.unsafeUninit (a, SeqIndex.fromIntUnsafe i)
+    fun uninit (a, i) =
+        if Primitive.Controls.safe
+          then let
+                  val i =
+                      (SeqIndex.fromInt i)
+                      handle Overflow => raise Subscript
+                in
+                  Raw.uninit (a, i)
+                end
+          else unsafeUninit (a, i)
+
+    val unsafeToArray = Primitive.ArrayFlat.Raw.unsafeToArray
+  end
+end
+
+structure ArrayFlatSlice: ARRAY_FLAT_SLICE_EXTRA = ArrayFlat.ArraySlice

basis-library/arrays-and-vectors/sequence.fun

@@ -66,7 +66,7 @@ structure SeqIndex =
             else fromIntUnsafe n
    end
 
-functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
+functor Sequence (S: PRIM_SEQUENCE): SEQUENCE where type 'a prim_array = 'a S.prim_array  =
    struct
       val op +! = SeqIndex.+!
       val op +$ = SeqIndex.+$
@@ -83,6 +83,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
 
       type 'a sequence = 'a S.sequence
       type 'a elt = 'a S.elt
+      type 'a prim_array = 'a S.prim_array
 
       (* S.maxLen must be representable as an Int.int already *)
       val maxLen = SeqIndex.toInt S.maxLen
@@ -130,6 +131,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
             type 'a sequence = 'a S.Slice.sequence
             type 'a elt = 'a S.Slice.elt
             type 'a slice = 'a S.Slice.slice
+            type 'a prim_array = 'a S.Slice.prim_array
 
             fun length sl = 
                if Primitive.Controls.safe
@@ -250,7 +252,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
                                        handle Overflow => raise Size)
                               else (fn (x, s) => s +! S.Slice.length (toSlice x))
                         val n = List.foldl add 0 xs
-                        val a = Primitive.Array.alloc n
+                        val a = S.unsafeArrayAlloc n
                         fun loop (di, xs) =
                            case xs of
                               [] => S.unsafeFromArray a
@@ -281,7 +283,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
                               else (fn (x, s) =>
                                        (s +! sepn +! S.Slice.length (toSlice x)))
                         val n = List.foldl add (S.Slice.length (toSlice x)) xs
-                        val a = Primitive.Array.alloc n
+                        val a = S.unsafeArrayAlloc n
                         fun loop (di, xs) =
                            case xs of
                               [] => raise Fail "Sequence.Slice.concatWithGen"

basis-library/arrays-and-vectors/sequence.sig

@@ -12,9 +12,11 @@ signature SEQUENCE =
    sig
       type 'a sequence
       type 'a elt
+      type 'a prim_array
 
       structure Slice : SLICE where type 'a sequence = 'a sequence
                                 and type 'a elt = 'a elt
+                                and type 'a prim_array = 'a prim_array
 
       val maxLen: int
       val length: 'a sequence -> int
@@ -25,8 +27,8 @@ signature SEQUENCE =
       val uninitIsNop: 'a sequence -> bool
       val uninit: 'a sequence * int -> unit
       val unsafeUninit: 'a sequence * int -> unit
-      val copy: {dst: 'a elt Array.array, di: int, src: 'a sequence} -> unit
-      val unsafeCopy: {dst: 'a elt Array.array, di: int, src: 'a sequence} -> unit
+      val copy: {dst: 'a elt prim_array, di: int, src: 'a sequence} -> unit
+      val unsafeCopy: {dst: 'a elt prim_array, di: int, src: 'a sequence} -> unit
       val tabulate: int * (int -> 'a elt) -> 'a sequence
       val appi: (int * 'a elt -> unit) -> 'a sequence -> unit 
       val app: ('a elt -> unit) -> 'a sequence -> unit 

basis-library/arrays-and-vectors/sequence0.sig

@@ -12,9 +12,12 @@ signature PRIM_SEQUENCE =
    sig
       type 'a sequence
       type 'a elt
+      type 'a prim_array
+      type 'a prim_vector
 
       structure Slice: PRIM_SLICE where type 'a sequence = 'a sequence
                                     and type 'a elt = 'a elt
+                                    and type 'a prim_array = 'a prim_array
 
       val maxLen: SeqIndex.int (* Must also be representable as an Int.int *)
       val length: 'a sequence -> SeqIndex.int
@@ -25,8 +28,8 @@ signature PRIM_SEQUENCE =
       val unsafeUninit: 'a sequence * SeqIndex.int -> unit
       val update: 'a sequence * SeqIndex.int * 'a elt -> unit
       val unsafeUpdate: 'a sequence * SeqIndex.int * 'a elt -> unit
-      val copy: {dst: 'a elt array, di: SeqIndex.int, src: 'a sequence} -> unit
-      val unsafeCopy: {dst: 'a elt array, di: SeqIndex.int, src: 'a sequence} -> unit
+      val copy: {dst: 'a elt prim_array, di: SeqIndex.int, src: 'a sequence} -> unit
+      val unsafeCopy: {dst: 'a elt prim_array, di: SeqIndex.int, src: 'a sequence} -> unit
       val tabulate: SeqIndex.int * (SeqIndex.int -> 'a elt) -> 'a sequence
       val appi: (SeqIndex.int * 'a elt -> unit) -> 'a sequence -> unit 
       val app: ('a elt -> unit) -> 'a sequence -> unit 
@@ -59,5 +62,6 @@ signature PRIM_SEQUENCE =
       val unfoldi: SeqIndex.int * 'b * (SeqIndex.int * 'b -> 'a elt * 'b) -> 'a sequence * 'b
       val unfold: SeqIndex.int * 'b * ('b -> 'a elt * 'b) -> 'a sequence * 'b
       val unsafeAlloc: SeqIndex.int -> 'a sequence
-      val unsafeFromArray: 'a elt array -> 'a sequence
+      val unsafeFromArray: 'a elt prim_array -> 'a sequence
+      val unsafeArrayAlloc: SeqIndex.int -> 'a prim_array
   end