Belt_Array
Belt.Array
Utililites for Array functions
let length: t('a) => int;
length xs
return the size of the array
let get: t('a) => int => option('a);
get arr i
If i <= 0 <= length arr
;returns Some value
where value
is the item at index i
If i
is out of range;returns None
Belt.Array.get [|"a";"b";"c"|] 0 = Some "a";;
Belt.Array.get [|"a";"b";"c"|] 3 = None;;
Belt.Array.get [|"a";"b";"c"|] (-1) = None;;
let getExn: t('a) => int => 'a;
getExn arr i
raise an exception if i
is out of range;otherwise return the value at index i
in arr
let getUnsafe: t('a) => int => 'a;
getUnsafe arr i
Unsafe
no bounds checking;this would cause type error if i
does not stay within range
let getUndefined: t('a) => int => Js.undefined('a);
getUndefined arr i
It does the samething in the runtime as getUnsafe
; it is type safe since the return type still track whether it is in range or not
let set: t('a) => int => 'a => bool;
set arr n x
modifies arr
in place; it replaces the nth element of arr
with x
let setExn: t('a) => int => 'a => unit;
setExn arr i x
raise an exception if i
is out of range
let setUnsafe: t('a) => int => 'a => unit;
let shuffleInPlace: t('a) => unit;
shuffleInPlace arr
randomly re-orders the items in arr
let reverseInPlace: t('a) => unit;
reverseInPlace arr
reverses items in arr
in place
let arr = [|10;11;12;13;14|];;
let () = reverseInPlace arr;;
arr = [|14;13;12;11;10|];;
let makeUninitialized: int => array(Js.undefined('a));
makeUninitialized n
creates an array of length n
filled with the undefined value. You must specify the type of data that will eventually fill the array.
let arr: string Js.undefined array = makeUninitialized 5;;
getExn arr 0 = Js.undefined;;
let makeUninitializedUnsafe: int => t('a);
`makeUninitializedUnsafe n`
Unsafe
let arr = Belt.Array.makeUninitializedUnsafe 5;;
let () = Js.log(Belt.Array.getExn arr 0);; (* undefined *)
Belt.Array.setExn arr 0 "example";;
let () = Js.log(Belt.Array.getExn arr 0 = "example");;
let make: int => 'a => t('a);
make n e
return an array of size n
filled with value e
let range: int => int => t(int);
range start finish
create an inclusive array
range 0 3 = [|0;1;2;3|];;
range 3 0 = [||] ;;
range 3 3 = [|3|];;
let rangeBy: int => int => step:int => t(int);
rangeBy start finish ~step
let makeByU: int => Js.Fn.arity1((int => 'a)) => t('a);
let makeBy: int => (int => 'a) => t('a);
makeBy n f
return an empty array when n
is negative return an array of size n
populated by f i
start from 0
to n - 1
makeBy 5 (fun i -> i) = [|0;1;2;3;4|];;
makeBy 5 (fun i -> i * i) = [|0;1;4;9;16|]
let makeByAndShuffleU: int => Js.Fn.arity1((int => 'a)) => t('a);
let makeByAndShuffle: int => (int => 'a) => t('a);
makeByAndShuffle n f
Equivalent to shuffle (makeBy n f)
let zip: t('a) => array('b) => array(('a, 'b));
zip a b
Create an array of pairs from corresponding elements of a
and b
. Stop with the shorter array
zip [|1;2|] [|3;4;5|] = [|(1, 3);(2, 4)|]
let zipByU: t('a) => array('b) => Js.Fn.arity2(('a => 'b => 'c)) => array('c);
let zipBy: t('a) => array('b) => ('a => 'b => 'c) => array('c);
zipBy xs ys f
Create an array by applying f
to corresponding elements of xs
and ys
Stops with shorter array
Equivalent to map (zip xs ys) (fun (a,b) -> f a b)
zipBy [|1;2;3|] [|4;5|] (fun a b -> 2 * a + b) = [|6;9|];;
let unzip: array(('a, 'b)) => (t('a), array('b));
unzip a
takes an array of pairs and creates a pair of arrays. The first array contains all the first items of the pairs; the second array contains all the second items.
unzip [|(1,2) ; (3,4)|] = ([|1;3|], [|2;4|]);;
unzip [|(1,2) ; (3,4) ; (5,6) ; (7,8)|] = ([|1;3;5;7|], [|2;4;6;8|]);;
slice xs offset len
creates a new array with the len
elements of xs
starting at offset
for
offset
can be negative;and is evaluated as length xs - offset
slice xs -1 1
means get the last element as a singleton array
slice xs (-len) len
will return a copy of the array
if the array does not have enough data;slice
extracts through the end of sequence.
if len
is negative;returns the empty array.
slice [|10;11;12;13;14;15;16|] ~offset: 2 ~len: 3 = [|12;13;14|];;
slice [|10;11;12;13;14;15;16|] ~offset: (-4) ~len: 3 = [|13;14;15|];;
slice [|10;11;12;13;14;15;16|] ~offset:4 ~len:9 = [|14;15;16|];;
sliceToEnd xs offset
creates a new array with the elements of xs
starting at offset
offset
can be negative;and is evaluated as length xs - offset
sliceToEnd xs -1
means get the last element as a singleton array
sliceToEnd xs 0
will return a copy of the array
sliceToEnd [|10;11;12;13;14;15;16|] 2 = [|12;13;14;15;16|];;
sliceToEnd [|10;11;12;13;14;15;16|] (-4) = [|13;14;15;16|];;
let fill: t('a) => offset:int => len:int => 'a => unit;
fill arr ~offset ~len x
Modifies arr
in place, storing x
in elements number offset
to offset + len - 1
.
offset
can be negative;and is evaluated as length arr - offset
fill arr ~offset:(-1) ~len:1
means fill the last element, if the array does not have enough data;fill
will ignore it
let arr = makeBy 5 (fun i -> i) ;;
fill arr ~offset:2 ~len:2 9 ;;
arr = [|0;1;9;9;4|];;
fill arr ~offset:7 ~len:2 8;;
arr = [|0;1;9;9;4|];;
blit ~src:v1 ~srcOffset:o1 ~dst:v2 ~dstOffset:o2 ~len
copies len
elements from array v1
;starting at element number o1
;to array v2
, starting at element number o2
.
It works correctly even if v1
and v2
are the same array;and the source and destination chunks overlap.
offset
can be negative;-1
means len - 1
;if len + offset
is still negative;it will be set as 0
For each of the examples;presume that v1 = [|10;11;12;13;14;15;16;17|]
and v2 = [|20;21;22;23;24;25;26;27|]
. The result shown is the content of the destination array.
Belt.Array.blit ~src: v1 ~srcOffset: 4 ~dst: v2 ~dstOffset: 2 ~len: 3 |.
[|20;21;14;15;16;25;26;27|]
Belt.Array.blit ~src: v1 ~srcOffset: 4 ~dst: v1 ~dstOffset: 2 ~len: 3 |.
[|10;11;14;15;16;15;16;17|]
Unsafe blit without bounds checking
let forEachU: t('a) => Js.Fn.arity1(('a => unit)) => unit;
let forEach: t('a) => ('a => unit) => unit;
forEach xs f
Call f
on each element of xs
from the beginning to end. f
returns unit
;so no new array is created. Use forEach
when you are primarily concerned with repetitively creating side effects.
forEach [|"a";"b";"c"|] (fun x -> Js.log("Item: " ^ x));;
(* prints:
Item: a
Item: b
Item: c
*)
let total = ref 0;;
forEach [|1;2;3;4|] (fun x -> total := !total + x);;
!total = 1 + 2 + 3 + 4;;
let mapU: t('a) => Js.Fn.arity1(('a => 'b)) => array('b);
let map: t('a) => ('a => 'b) => array('b);
map xs f
let flatMapU: t('a) => Js.Fn.arity1(('a => t('b))) => t('b);
flatMap xs f
**return** a new array by calling `f` for each element of `xs` from the beginning to end, and then concatenating the results ``` flatMap |1;2|
(fun x-> |x + 10;x + 20|
) = |11;21;12;22|
```
let getByU: t('a) => Js.Fn.arity1(('a => bool)) => option('a);
let getBy: t('a) => ('a => bool) => option('a);
getBy xs p
returns Some value
for the first value in xs
that satisifies the predicate function p
; returns None
if no element satisifies the function.
getBy [|1;4;3;2|] (fun x -> x mod 2 = 0) = Some 4
getBy [|15;13;11|] (fun x -> x mod 2 = 0) = None
let getIndexByU: t('a) => Js.Fn.arity1(('a => bool)) => option(int);
let getIndexBy: t('a) => ('a => bool) => option(int);
getIndexBy xs p
returns Some index
for the first value in xs
that satisifies the predicate function p
; returns None
if no element satisifies the function.
getIndexBy [|1;4;3;2|] (fun x -> x mod 2 = 0) = Some 1
getIndexBy [|15;13;11|] (fun x -> x mod 2 = 0) = None
let keepU: t('a) => Js.Fn.arity1(('a => bool)) => t('a);
let keepWithIndexU: t('a) => Js.Fn.arity2(('a => int => bool)) => t('a);
let keepMapU: t('a) => Js.Fn.arity1(('a => option('b))) => array('b);
let keepMap: t('a) => ('a => option('b)) => array('b);
keepMap xs p
let forEachWithIndexU: t('a) => Js.Fn.arity2((int => 'a => unit)) => unit;
let forEachWithIndex: t('a) => (int => 'a => unit) => unit;
forEachWithIndex xs f
The same as forEach
; except that f
is supplied with two arguments: the index starting from 0 and the element from xs
forEachWithIndex [|"a";"b";"c"|] (fun i x -> Js.log("Item " ^ (string_of_int i) ^ " is " ^ x));;
(* prints:
Item 0 is a
Item 1 is b
Item 2 is c
*)
let total = ref 0 ;;
forEachWithIndex [|10;11;12;13|] (fun i x -> total := !total + x + i);;
!total = 0 + 10 + 1 + 11 + 2 + 12 + 3 + 13;;
let mapWithIndexU: t('a) => Js.Fn.arity2((int => 'a => 'b)) => t('b);
mapWithIndex xs f
applies f
to each element of xs
. Function f
takes two arguments: the index starting from 0 and the element from xs
.
mapWithIndex [|1;2;3|] (fun i x -> i + x) =
[|0 + 1; 1 + 2; 2 + 3|]
let partitionU: t('a) => Js.Fn.arity1(('a => bool)) => (t('a), t('a));
partition f a
split array into tuple of two arrays based on predicate f; first of tuple where predicate cause true, second where predicate cause false
partition [|1;2;3;4;5|] (fun x -> x mod 2 = 0 ) = ([|2;4|], [|1;2;3|]);;
partition [|1;2;3;4;5|] (fun x -> x mod 2 <> 0 ) = ([|1;2;3|], [|2;4|]);;
let reduceU: array('b) => 'a => Js.Fn.arity2(('a => 'b => 'a)) => 'a;
reduce xs init f
Applies f
to each element of xs
from beginning to end. Function f
has two parameters: the item from the list and an “accumulator”;which starts with a value of init
. reduce
returns the final value of the accumulator.
reduce [|2;3;4|] 1 (+) = 10;;
reduce [|"a";"b";"c";"d"|] "" (^) = "abcd";;
let reduceReverseU: array('b) => 'a => Js.Fn.arity2(('a => 'b => 'a)) => 'a;
reduceReverse xs init f
Works like reduce
;except that function f
is applied to each item of xs
from the last back to the first.
reduceReverse [|"a";"b";"c";"d"|] "" (^) = "dcba";;
let reduceReverse2U:
t('a) =>
array('b) =>
'c =>
Js.Fn.arity3(('c => 'a => 'b => 'c)) =>
'c;
let reduceReverse2: t('a) => array('b) => 'c => ('c => 'a => 'b => 'c) => 'c;
reduceReverse2 xs ys init f
Reduces two arrays xs
and ys
;taking items starting at min (length xs) (length ys)
down to and including zero.
reduceReverse2 [|1;2;3|] [|1;2|] 0 (fun acc x y -> acc + x + y) = 6
let reduceWithIndexU:
t('a) =>
'b =>
Js.Fn.arity3(('b => 'a => int => 'b)) =>
'b;
let reduceWithIndex: t('a) => 'b => ('b => 'a => int => 'b) => 'b;
reduceWithIndex xs f
Applies f
to each element of xs
from beginning to end. Function f
has three parameters: the item from the array and an “accumulator”, which starts with a value of init
and the index of each element. reduceWithIndex
returns the final value of the accumulator.
reduceWithIndex [|1;2;3;4|] 0 (fun acc x i -> acc + x + i) = 16;
let joinWithU: t('a) => string => Js.Fn.arity1(('a => string)) => string;
let joinWith: t('a) => string => ('a => string) => string;
joinWith xs sep toString
Concatenates all the elements of xs
converted to string with toString
, each separated by sep
, the string given as the second argument, into a single string. If the array has only one element, then that element will be returned without using the separator. If the array is empty, the empty string will be returned.
joinWith [|0; 1|] ", " string_of_int = "0, 1"
joinWith [||] " " string_of_int = ""
joinWith [|1|] " " string_of_int = "1"
let someU: t('a) => Js.Fn.arity1(('a => bool)) => bool;
let some: t('a) => ('a => bool) => bool;
some xs p
let everyU: t('a) => Js.Fn.arity1(('a => bool)) => bool;
let every: t('a) => ('a => bool) => bool;
every xs p
let every2U: t('a) => t('b) => Js.Fn.arity2(('a => 'b => bool)) => bool;
every2 xs ys p
returns true if p xi yi
is true for all pairs of elements up to the shorter length (i.e. min (length xs) (length ys)
)
every2 [|1;2;3|] [|0;1|] (>) = true;;
every2 [||] [|1|] (fun x y -> x > y) = true;;
every2 [|2;3|] [|1|] (fun x y -> x > y) = true;;
every2 [|0;1|] [|5;0|] (fun x y -> x > y) = false;
let some2U: t('a) => t('b) => Js.Fn.arity2(('a => 'b => bool)) => bool;
some2 xs ys p
returns true if p xi yi
is true for any pair of elements up to the shorter length (i.e. min (length xs) (length ys)
)
some2 [|0;2|] [|1;0;3|] (>) = true ;;
(some2 [||] [|1|] (fun x y -> x > y)) = false;;
(some2 [|2;3|] [|1;4|] (fun x y -> x > y)) = true;;
let cmpU: t('a) => t('a) => Js.Fn.arity2(('a => 'a => int)) => int;
cmp xs ys f
length xs <> length ys
;returning -1 iflength xs < length ys
or 1 if length xs > length ys
f x y
. f
returnsx
is “less than” y
x
is “equal to” y
x
is “greater than” y
f
;or zero if f
returns zero for all x
and y
.cmp [|1; 3; 5|] [|1; 4; 2|] (fun a b -> compare a b) = -1;;
cmp [|1; 3; 5|] [|1; 2; 3|] (fun a b -> compare a b) = 1;;
cmp [|1; 3; 5|] [|1; 3; 5|] (fun a b -> compare a b) = 0;;
let eqU: t('a) => t('a) => Js.Fn.arity2(('a => 'a => bool)) => bool;
eq xs ys
f xi yi
;and return true if all results are true;false otherwiseeq [|1; 2; 3|] [|-1; -2; -3|] (fun a b -> abs a = abs b) = true
let truncateToLengthUnsafe: t('a) => int => unit;
Unsafe truncateToLengthUnsafe xs n
sets length of array xs
to n
.
If n
is greater than the length of xs
;the extra elements are set to Js.Null_undefined.null
If n
is less than zero;raises a RangeError
.
let arr = [|"ant";"bee";"cat";"dog";"elk"|];;
let () = truncateToLengthUnsafe arr 3;;
arr = [|"ant";"bee";"cat"|];;
let initU: int => Js.Fn.arity1((int => 'a)) => t('a);
let init: int => (int => 'a) => t('a);
let push: t('a) => 'a => unit;
arr->push(item)
push element `item` into the array