API / Js / Typed_array / S

S

elt

RESCRIPT

type elt

typed_array

RESCRIPT

type typed_array<'a>

t

RESCRIPT

type t = typed_array<elt>

unsafe_get

RESCRIPT

let unsafe_get: (t, int) => elt

unsafe_set

RESCRIPT

let unsafe_set: (t, int, elt) => unit

buffer

RESCRIPT

let buffer: t => array_buffer

byteLength

RESCRIPT

let byteLength: t => int

byteOffset

RESCRIPT

let byteOffset: t => int

setArray

RESCRIPT

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

setArrayOffset

RESCRIPT

let setArrayOffset: (array<elt>, int, t) => unit

length

RESCRIPT

let length: t => int

copyWithin

RESCRIPT

let copyWithin: (~to_: int, t) => t

copyWithinFrom

RESCRIPT

let copyWithinFrom: (~to_: int, ~from: int, t) => t

copyWithinFromRange

RESCRIPT

let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t

fillInPlace

RESCRIPT

let fillInPlace: (elt, t) => t

fillFromInPlace

RESCRIPT

let fillFromInPlace: (elt, ~from: int, t) => t

fillRangeInPlace

RESCRIPT

let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t

reverseInPlace

RESCRIPT

let reverseInPlace: t => t

sortInPlace

RESCRIPT

let sortInPlace: t => t

sortInPlaceWith

RESCRIPT

let sortInPlaceWith: ((elt, elt) => int, t) => t

includes

RESCRIPT

let includes: (elt, t) => bool

indexOf

RESCRIPT

let indexOf: (elt, t) => int

indexOfFrom

RESCRIPT

let indexOfFrom: (elt, ~from: int, t) => int

join

RESCRIPT

let join: t => string

joinWith

RESCRIPT

let joinWith: (string, t) => string

lastIndexOf

RESCRIPT

let lastIndexOf: (elt, t) => int

lastIndexOfFrom

RESCRIPT

let lastIndexOfFrom: (elt, ~from: int, t) => int

slice

RESCRIPT

let slice: (~start: int, ~end_: int, t) => t

copy

RESCRIPT

let copy: t => t

sliceFrom

RESCRIPT

let sliceFrom: (int, t) => t

subarray

RESCRIPT

let subarray: (~start: int, ~end_: int, t) => t

subarrayFrom

RESCRIPT

let subarrayFrom: (int, t) => t

toString

RESCRIPT

let toString: t => string

toLocaleString

RESCRIPT

let toLocaleString: t => string

every

RESCRIPT

let every: (elt => bool, t) => bool

everyi

RESCRIPT

let everyi: ((elt, int) => bool, t) => bool

filter

RESCRIPT

let filter: (elt => bool, t) => t

filteri

RESCRIPT

let filteri: ((elt, int) => bool, t) => t

find

RESCRIPT

let find: (elt => bool, t) => Js.undefined<elt>

findi

RESCRIPT

let findi: ((elt, int) => bool, t) => Js.undefined<elt>

findIndex

RESCRIPT

let findIndex: (elt => bool, t) => int

findIndexi

RESCRIPT

let findIndexi: ((elt, int) => bool, t) => int

forEach

RESCRIPT

let forEach: (elt => unit, t) => unit

forEachi

RESCRIPT

let forEachi: ((elt, int) => unit, t) => unit

map

RESCRIPT

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

mapi

RESCRIPT

let mapi: ((elt, int) => 'b, t) => typed_array<'b>

reduce

RESCRIPT

let reduce: (('b, elt) => 'b, 'b, t) => 'b

reducei

RESCRIPT

let reducei: (('b, elt, int) => 'b, 'b, t) => 'b

reduceRight

RESCRIPT

let reduceRight: (('b, elt) => 'b, 'b, t) => 'b

reduceRighti

RESCRIPT

let reduceRighti: (('b, elt, int) => 'b, 'b, t) => 'b

some

RESCRIPT

let some: (elt => bool, t) => bool

somei

RESCRIPT

let somei: ((elt, int) => bool, t) => bool