Unsafe operations for array uninitialization and raw arrays

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

@@ -39,11 +39,15 @@ signature ARRAY_SLICE_EXTRA =
    sig
       include ARRAY_SLICE
 
+      val uninitIsNop: 'a slice -> bool
+      val uninit: 'a slice * int -> unit
       val unsafeSub: 'a slice * int -> 'a
       val unsafeCopy: {dst: 'a Array.array, di: int, src: 'a slice} -> unit
       val unsafeCopyVec: {dst: 'a Array.array, di: int, src: 'a VectorSlice.slice} -> unit
       val unsafeSlice: 'a array * 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 array
       val toList: 'a slice -> 'a list

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

@@ -40,16 +40,32 @@ signature ARRAY_EXTRA =
 
       structure ArraySlice: ARRAY_SLICE_EXTRA 
 
-      val uninit: int -> 'a array
-      val unsafeUninit: int -> 'a array
-      val unsafeSub: 'a array * int -> 'a
-      val unsafeUpdate: 'a array * int * 'a -> unit
+      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.sml

@@ -25,22 +25,50 @@ structure Array: ARRAY_EXTRA =
          struct
             open Slice
             val vector = Primitive.Array.Slice.vector
-            fun update x = updateMk Primitive.Array.updateUnsafe x
-            fun unsafeUpdate x = unsafeUpdateMk Primitive.Array.updateUnsafe x
             val copyVec = Vector.VectorSlice.copy
             val unsafeCopyVec = Vector.VectorSlice.unsafeCopy
             fun modifyi f sl = Primitive.Array.Slice.modifyi (wrap2 f) sl
             val modify = Primitive.Array.Slice.modify
          end
 
       val array = new
+      val unsafeArray = unsafeNew
       val vector = Primitive.Array.vector
-      fun update x = updateMk Primitive.Array.updateUnsafe x
-      fun unsafeUpdate x = unsafeUpdateMk Primitive.Array.updateUnsafe x
       val copyVec = Vector.copy
       val unsafeCopyVec = Vector.unsafeCopy
       fun modifyi f sl = Primitive.Array.modifyi (wrap2 f) sl
       val modify = Primitive.Array.modify
+
+      structure Raw = Primitive.Array.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.Array.Raw.unsafeToArray
+         end
    end
 
 structure ArraySlice: ARRAY_SLICE_EXTRA = Array.ArraySlice

basis-library/arrays-and-vectors/array2.sml

@@ -114,8 +114,8 @@ structure Array2 : ARRAY2 =
                   rows = rows,
                   cols = cols}
       in
-         fun uninit' (rows, cols) =
-            make (rows, cols, Primitive.Array.uninit)
+         fun alloc' (rows, cols) =
+            make (rows, cols, Primitive.Array.alloc)
          fun array' (rows, cols, init) =
             make (rows, cols, fn size => Primitive.Array.new (size, init))
       end
@@ -135,14 +135,14 @@ structure Array2 : ARRAY2 =
                else doit (SeqIndex.fromIntUnsafe rows,
                           SeqIndex.fromIntUnsafe cols)
       in
-         fun uninit (rows, cols) =
-            make (rows, cols, fn (rows, cols) => uninit' (rows, cols))
+         fun alloc (rows, cols) =
+            make (rows, cols, fn (rows, cols) => alloc' (rows, cols))
          fun array (rows, cols, init) =
             make (rows, cols, fn (rows, cols) => array' (rows, cols, init))
       end
 
       fun array0 (): 'a array =
-         {array = Primitive.Array.uninit 0,
+         {array = Primitive.Array.alloc 0,
           rows = 0,
           cols = 0}
 
@@ -192,7 +192,7 @@ structure Array2 : ARRAY2 =
                let
                   val cols = length row1
                   val a as {array, cols = cols', ...} = 
-                     uninit (length rows, cols)
+                     alloc (length rows, cols)
                   val _ =
                      List.foldl
                      (fn (row: 'a list, i) =>
@@ -300,7 +300,7 @@ structure Array2 : ARRAY2 =
 
       fun tabulate trv (rows, cols, f) =
          let 
-            val a = uninit (rows, cols)
+            val a = alloc (rows, cols)
             val () = modifyi trv (fn (r, c, _) => f (r, c)) (wholeRegion a)
          in 
             a

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

@@ -40,7 +40,11 @@ signature MONO_ARRAY_SLICE_EXTRA =
       val concat: slice list -> array
       val toList: slice -> elem list
       val toPoly: slice -> elem ArraySlice.slice
+      val uninitIsNop: slice -> bool
+      val uninit: slice * int -> unit
       val unsafeSlice: array * int * int option -> slice
       val unsafeSub: slice * int -> elem
       val unsafeSubslice: slice * int * int option -> slice
+      val unsafeUninit: slice * int -> unit
+      val unsafeUpdate: slice * int * elem -> unit
    end

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

@@ -39,14 +39,19 @@ signature MONO_ARRAY_EXTRA =
           and type vector = vector
           and type vector_slice = vector_slice
 
-      val uninit: int -> array
+      val alloc: int -> array
+      val uninitIsNop: array -> bool
+      val uninit: array * int -> unit
 
       val concat: array list -> array
       val duplicate: array -> array
       val fromPoly: elem Array.array -> array
       val toList: array -> elem list
       val toPoly: array -> elem Array.array
       val unfoldi: int * 'a * (int * 'a -> elem * 'a) -> array * 'a
+
+      val unsafeAlloc: int -> array
       val unsafeSub: array * int -> elem
+      val unsafeUninit: array * int -> unit
       val unsafeUpdate: array * int * elem -> unit
    end

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

@@ -59,6 +59,11 @@ structure SeqIndex =
       in
          val toInt = S.f
       end
+
+      fun fromIntForLength n =
+         if Primitive.Controls.safe
+            then (fromInt n) handle Overflow => raise Size
+            else fromIntUnsafe n
    end
 
 functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
@@ -82,31 +87,27 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
       (* S.maxLen must be representable as an Int.int already *)
       val maxLen = SeqIndex.toInt S.maxLen
 
-      fun fromIntForLength n =
-         if Primitive.Controls.safe
-            then (SeqIndex.fromInt n) handle Overflow => raise Size
-            else SeqIndex.fromIntUnsafe n
-
       fun length s = 
          if Primitive.Controls.safe
             then (SeqIndex.toInt (S.length s))
                  handle Overflow => raise Fail "Sequence.length"
             else SeqIndex.toIntUnsafe (S.length s)
 
-      fun uninit n = S.uninit (fromIntForLength n)
-      fun unsafeUninit n = S.unsafeUninit (SeqIndex.fromIntUnsafe n)
+      fun alloc n = S.alloc (SeqIndex.fromIntForLength n)
+      fun unsafeAlloc n = S.unsafeAlloc (SeqIndex.fromIntUnsafe n)
 
       fun create n =
          let
-            val {done, sub, update} = S.create (fromIntForLength n)
+            val {done, sub, update} = S.create (SeqIndex.fromIntForLength n)
          in
             {done = done,
              sub = unwrap1 sub,
              update = unwrap2 update}
          end
 
-      fun unfoldi (n, b, f) = S.unfoldi (fromIntForLength n, b, wrap2 f)
-      fun unfold (n, b, f) = S.unfold (fromIntForLength n, b, f)
+      fun unfoldi (n, b, f) = S.unfoldi (SeqIndex.fromIntForLength n, b, wrap2 f)
+      fun unfold (n, b, f) = S.unfold (SeqIndex.fromIntForLength n, b, f)
+      fun unsafeUnfold (n, b, f) = S.unfold (SeqIndex.fromIntUnsafe n, b, f)
 
       fun seq0 () = #1 (unfold (0, (), fn _ => raise Fail "Sequence.seq0"))
 
@@ -115,6 +116,8 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
 
       fun new (n, x) = 
          #1 (unfold (n, (), fn () => (x, ())))
+      fun unsafeNew (n, x) =
+         #1 (unsafeUnfold (n, (), fn () => (x, ())))
 
       fun fromList l =
          #1 (unfold (List.length l, l, fn l =>
@@ -147,19 +150,32 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
                        end
                   else unsafeSub (sl, i)
 
-            fun unsafeUpdateMk updateUnsafe (sl, i, x) =
-               (S.Slice.unsafeUpdateMk updateUnsafe) 
-                   (sl, SeqIndex.fromIntUnsafe i, x)
-            fun updateMk updateUnsafe (sl, i, x) = 
+            fun unsafeUpdate (sl, i, x) =
+               S.Slice.unsafeUpdate (sl, SeqIndex.fromIntUnsafe i, x)
+            fun update (sl, i, x) =
+               if Primitive.Controls.safe
+                  then let
+                          val i =
+                             (SeqIndex.fromInt i)
+                             handle Overflow => raise Subscript
+                       in
+                          S.Slice.update (sl, i, x)
+                       end
+               else unsafeUpdate (sl, i, x)
+
+            val uninitIsNop = S.Slice.uninitIsNop
+            fun unsafeUninit (sl, i) =
+               S.Slice.unsafeUninit (sl, SeqIndex.fromIntUnsafe i)
+            fun uninit (sl, i) =
                if Primitive.Controls.safe
                   then let
                           val i =
                              (SeqIndex.fromInt i)
                              handle Overflow => raise Subscript
                        in
-                          (S.Slice.updateMk updateUnsafe) (sl, i, x)
+                          S.Slice.uninit (sl, i)
                        end
-               else (unsafeUpdateMk updateUnsafe) (sl, i, x)
+               else unsafeUninit (sl, i)
 
             fun unsafeCopy {dst, di, src} =
                S.Slice.unsafeCopy
@@ -234,7 +250,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
                                        handle Overflow => raise Size)
                               else (fn (sl, s) => s +? S.Slice.length sl)
                         val n = List.foldl add 0 sls
-                        val a = Primitive.Array.uninit n
+                        val a = Primitive.Array.alloc n
                         fun loop (di, sls) =
                            case sls of
                               [] => S.unsafeFromArray a
@@ -260,7 +276,7 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
                               else (fn (sl, s) => 
                                        (s +? sepn +? S.Slice.length sl))
                         val n = List.foldl add (S.Slice.length sl) sls
-                        val a = Primitive.Array.uninit n
+                        val a = Primitive.Array.alloc n
                         fun loop (di, sls) =
                            case sls of
                               [] => raise Fail "Sequence.Slice.concatWith"
@@ -433,10 +449,11 @@ functor Sequence (S: PRIM_SEQUENCE): SEQUENCE =
       in
         fun sub (seq, i) = Slice.sub (Slice.full seq, i)
         fun unsafeSub (seq, i) = Slice.unsafeSub (Slice.full seq, i) 
-        fun updateMk updateUnsafe (seq, i, x) =
-           Slice.updateMk updateUnsafe (Slice.full seq, i, x)
-        fun unsafeUpdateMk updateUnsafe (seq, i, x) =
-           Slice.unsafeUpdateMk updateUnsafe (Slice.full seq, i, x)
+        fun update (seq, i, x) = Slice.update (Slice.full seq, i, x)
+        fun unsafeUpdate (seq, i, x) = Slice.unsafeUpdate (Slice.full seq, i, x)
+        fun uninitIsNop seq = Slice.uninitIsNop (Slice.full seq)
+        fun uninit (seq, i) = Slice.uninit (Slice.full seq, i)
+        fun unsafeUninit (seq, i) = Slice.unsafeUninit (Slice.full seq, i)
         fun copy {dst, di, src} =
            Slice.copy {dst = dst, di = di, src = Slice.full src}
         fun unsafeCopy {dst, di, src} =

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

@@ -17,20 +17,17 @@ signature SEQUENCE =
                                 and type 'a elt = 'a elt
 
       val maxLen: int
-      val tabulate: int * (int -> 'a elt) -> 'a sequence 
       val length: 'a sequence -> int
       val sub: 'a sequence * int -> 'a elt
       val unsafeSub: 'a sequence * int -> 'a elt 
-      (* updateMk,unsafeUpdateMk:
-       * ('a sequence * SeqIndex.int * 'a elt -> unit) 
-       * should be primitive unsafe update
-       *)
-      val updateMk: ('a sequence * SeqIndex.int * 'a elt -> unit) ->
-                     ('a sequence * int * 'a elt) -> unit
-      val unsafeUpdateMk: ('a sequence * SeqIndex.int * 'a elt -> unit) ->
-                           ('a sequence * int * 'a elt) -> unit
+      val update: 'a sequence * int * 'a elt -> unit
+      val unsafeUpdate: 'a sequence * int * 'a elt -> unit
+      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 tabulate: int * (int -> 'a elt) -> 'a sequence
       val appi: (int * 'a elt -> unit) -> 'a sequence -> unit 
       val app: ('a elt -> unit) -> 'a sequence -> unit 
       val mapi : (int * 'a elt -> 'b elt) -> 'a sequence -> 'b sequence 
@@ -51,6 +48,7 @@ signature SEQUENCE =
       val concat: 'a sequence list -> 'a sequence 
 
       (* Extra *)
+      val alloc: int -> 'a sequence
       val append: 'a sequence * 'a sequence -> 'a sequence 
       val create:
          int -> {done: unit -> 'a sequence,
@@ -60,8 +58,8 @@ signature SEQUENCE =
       val new: int * 'a elt -> 'a sequence 
       val unfoldi: int * 'b * (int * 'b -> 'a elt * 'b) -> 'a sequence * 'b
       val unfold: int * 'b * ('b -> 'a elt * 'b) -> 'a sequence * 'b
-      val uninit: int -> 'a sequence
-      val unsafeUninit: int -> 'a sequence
+      val unsafeAlloc: int -> 'a sequence
+      val unsafeNew: int * 'a elt -> 'a sequence
 
       (* Used to implement Substring/String functions *)
       val isPrefix: ('a elt * 'a elt -> bool) -> 'a sequence -> 'a sequence -> bool