alice
library
manual.
signature MONO_ARRAY_SLICE
structure CharArraySlice : MONO_ARRAY_SLICE
where type elem = char
and type vector = string
and type vector_slice = substring
and type array = CharArray.t
structure Word8ArraySlice : MONO_ARRAY_SLICE
where type elem = Word8.t
and type vector = Word8Vector.t
and type vector_slice = Word8VectorSlice.t
and type array = Word8Array.t
An extended version of the Standard ML Basis' MONO_ARRAY_SLICE signature.
See also: MONO_ARRAY ArraySlice, MONO_VECTOR_SLICE
Imported implicitly.
signature MONO_ARRAY_SLICE =
sig
type elem
type vector
type vector_slice
type array
type slice
type t = slice
val full : array -> slice
val slice : array * int * int option -> slice
val subslice : slice * int * int option -> slice
val vector : slice -> vector
val toVector : slice -> vector
val toList : slice -> elem list
val length : slice -> int
val isEmpty : slice -> bool
val base : slice -> array * int * int
val sub : slice * int -> elem
val update : slice * int * elem -> unit
val swap : slice * int * int -> unit
val getItem : slice -> (elem * slice) option
val triml : int -> slice -> slice
val trimr : int -> slice -> slice
val splitAt : slice * int -> slice * slice
val splitl : (elem -> bool) -> slice -> slice * slice
val splitr : (elem -> bool) -> slice -> slice * slice
val dropl : (elem -> bool) -> slice -> slice
val dropr : (elem -> bool) -> slice -> slice
val takel : (elem -> bool) -> slice -> slice
val taker : (elem -> bool) -> slice -> slice
val rev : slice -> unit
val copy : {src : slice, dst : array, di : int} -> unit
val copyVec : {src : vector_slice, dst : array, di : int} -> unit
val app : (elem -> unit) -> slice -> unit
val appr : (elem -> unit) -> slice -> unit
val modify : (elem -> elem) -> slice -> unit
val foldl : (elem * 'a -> 'a) -> 'a -> slice -> 'a
val foldr : (elem * 'a -> 'a) -> 'a -> slice -> 'a
val all : (elem -> bool) -> slice -> bool
val exists : (elem -> bool) -> slice -> bool
val find : (elem -> bool) -> slice -> elem option
val appi : (int * elem -> unit) -> slice -> unit
val appri : (int * elem -> unit) -> slice -> unit
val modifyi : (int * elem -> elem) -> slice -> unit
val foldli : (int * elem * 'a -> 'a) -> 'a -> slice -> 'a
val foldri : (int * elem * 'a -> 'a) -> 'a -> slice -> 'a
val alli : (int * elem -> bool) -> slice -> bool
val existsi : (int * elem -> bool) -> slice -> bool
val findi : (int * elem -> bool) -> slice -> (int * elem) option
val contains : (elem * elem -> bool) -> slice -> elem -> bool
val notContains : (elem * elem -> bool) -> slice -> elem -> bool
val equal : (elem * elem -> bool) -> slice * slice -> bool
val collate : (elem * elem -> order) -> slice * slice -> order
val isSorted : (elem * elem -> order) -> slice -> bool
val sort : (elem * elem -> order) -> slice -> unit
end
Items not described here are as in the Standard ML Basis' MONO_ARRAY_SLICE signature.
A local synonym for type slice.
Creates a vector of the elements of sl. Equivalent to vector sl.
Creates a list of the elements of sl in order of increasing indices.
Reverses in-place the order of elements in the slice sl.
Swaps the ith and jth element of slice sl. If i < 0 or |sl| <= i, or j < 0 or |sl| <= j, then the Subscript exception is raised.
These functions remove k elements from the left (respectively, right) of the slice sl. If k is greater than the size of the slice, an empty slice is returned. Specifically, for a slice sl = slice(arr,i,j) and k ≤ j, we have:
triml k sl = slice(arr, i+k, j-k)
trimr k sl = slice(arr, i, j-k)
The exception Subscript is raised if k < 0. This exception is raised when triml k or trimr k is evaluated.
Returns the pair of slices (sl1, sl2), where sl1 contains the first i characters of sl and sl2 contains the rest, assuming 0 ≤ i ≤ size sl. Otherwise, it raises Subscript.
These functions scan sl from left to right (respectively, right to left) looking for the first element that does not satisfy the predicate f. They return the pair (sl1, sl2) giving the split of the slice into the span up to that element and the rest. The slice sl1 is the left side of the split, sl2the right side.
These routines scan the slice sl for the first element not satisfying the predicate f. The functions dropl and takel scan left to right (i.e., increasing indices), while dropr and taker scan from the right. The drop functions drop the maximal subslice consisting of elements satisfying the predicate, while the take functions return the maximal such subslice. These can be defined in terms of the split operations:
takel f sl = #1(splitl f sl)
dropl f sl = #2(splitl f sl)
taker f sl = #2(splitr f sl)
dropr f sl = #1(splitr f sl)
Like app and appi, but apply f in right to left order (i.e., decreasing indices). The expression appr f sl is equivalent to:
appri (f o #2) sl
Indexed versions of the functions all and exists. The index of each element is passed to f as an additional argument. The following equivalences hold:
all f sl = alli (f o #2) sl
exists f sl = existsi (f o #2) sl
Returns true if the element a occurs in the slice sl, with respect to the element equality eq; otherwise false.
Returns true if the element a does not occur in the slice sl, with respect to the element equality eq; otherwise false. Equivalent to not(contains eq sl a).
Creates an equality function on slices given an equality on the element type.
Returns true iff the elements in sl are sorted with respect to the ordering function f.
Sorts the elements in the slice sl with respect to the ordering function f. Sorting may be unstable with respect to equal elements.