API / Core / Typedarray

TypedArray

t

RESCRIPT

type t<'a>

get

RESCRIPT

let get: (t<'a>, int) => option<'a>

set

RESCRIPT

let set: (t<'a>, int, 'a) => unit

buffer

RESCRIPT

let buffer: t<'a> => Core__ArrayBuffer.t

byteLength

RESCRIPT

let byteLength: t<'a> => int

byteOffset

RESCRIPT

let byteOffset: t<'a> => int

setArray

RESCRIPT

let setArray: (t<'a>, array<'a>) => unit

setArrayFrom

RESCRIPT

let setArrayFrom: (t<'a>, array<'a>, int) => unit

length

RESCRIPT

let length: t<'a> => int

copyAllWithin

RESCRIPT

let copyAllWithin: (t<'a>, ~target: int) => array<'a>

copyWithinToEnd

RESCRIPT

let copyWithinToEnd: (t<'a>, ~target: int, ~start: int) => array<'a>

copyWithin

RESCRIPT

let copyWithin: (t<'a>, ~target: int, ~start: int, ~end: int) => array<'a>

fillAll

RESCRIPT

let fillAll: (t<'a>, 'a) => t<'a>

fillToEnd

RESCRIPT

let fillToEnd: (t<'a>, 'a, ~start: int) => t<'a>

fill

RESCRIPT

let fill: (t<'a>, 'a, ~start: int, ~end: int) => t<'a>

reverse

RESCRIPT

let reverse: t<'a> => unit

toReversed

RESCRIPT

let toReversed: t<'a> => t<'a>

sort

RESCRIPT

let sort: (t<'a>, ('a, 'a) => Core__Ordering.t) => unit

toSorted

RESCRIPT

let toSorted: (t<'a>, ('a, 'a) => Core__Ordering.t) => t<'a>

with

RESCRIPT

let with: (t<'a>, int, 'a) => t<'a>

includes

RESCRIPT

let includes: (t<'a>, 'a) => bool

indexOf

RESCRIPT

let indexOf: (t<'a>, 'a) => int

indexOfFrom

RESCRIPT

let indexOfFrom: (t<'a>, 'a, int) => int

joinWith

RESCRIPT

let joinWith: (t<'a>, string) => string

lastIndexOf

RESCRIPT

let lastIndexOf: (t<'a>, 'a) => int

lastIndexOfFrom

RESCRIPT

let lastIndexOfFrom: (t<'a>, 'a, int) => int

slice

RESCRIPT

let slice: (t<'a>, ~start: int, ~end: int) => t<'a>

sliceToEnd

RESCRIPT

let sliceToEnd: (t<'a>, ~start: int) => t<'a>

copy

RESCRIPT

let copy: t<'a> => t<'a>

subarray

RESCRIPT

let subarray: (t<'a>, ~start: int, ~end: int) => t<'a>

subarrayToEnd

RESCRIPT

let subarrayToEnd: (t<'a>, ~start: int) => t<'a>

toString

RESCRIPT

let toString: t<'a> => string

toLocaleString

RESCRIPT

let toLocaleString: t<'a> => string

every

RESCRIPT

let every: (t<'a>, 'a => bool) => bool

everyWithIndex

RESCRIPT

let everyWithIndex: (t<'a>, ('a, int) => bool) => bool

filter

RESCRIPT

let filter: (t<'a>, 'a => bool) => t<'a>

filterWithIndex

RESCRIPT

let filterWithIndex: (t<'a>, ('a, int) => bool) => t<'a>

find

RESCRIPT

let find: (t<'a>, 'a => bool) => option<'a>

findWithIndex

RESCRIPT

let findWithIndex: (t<'a>, ('a, int) => bool) => option<'a>

findIndex

RESCRIPT

let findIndex: (t<'a>, 'a => bool) => int

findIndexWithIndex

RESCRIPT

let findIndexWithIndex: (t<'a>, ('a, int) => bool) => int

forEach

RESCRIPT

let forEach: (t<'a>, 'a => unit) => unit

forEachWithIndex

RESCRIPT

let forEachWithIndex: (t<'a>, ('a, int) => unit) => unit

map

RESCRIPT

let map: (t<'a>, 'a => 'b) => t<'b>

mapWithIndex

RESCRIPT

let mapWithIndex: (t<'a>, ('a, int) => 'b) => t<'b>

reduce

RESCRIPT

let reduce: (t<'a>, ('b, 'a) => 'b, 'b) => 'b

reduceWithIndex

RESCRIPT

let reduceWithIndex: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b

reduceRight

RESCRIPT

let reduceRight: (t<'a>, ('b, 'a) => 'b, 'b) => 'b

reduceRightWithIndex

RESCRIPT

let reduceRightWithIndex: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b

some

RESCRIPT

let some: (t<'a>, 'a => bool) => bool

someWithIndex

RESCRIPT

let someWithIndex: (t<'a>, ('a, int) => bool) => bool