Int8Array (melange.Js.Typed

type elt = int;

type typed_array('a);

type t = typed_array(elt);

let unsafe_get: t => int => elt;

let unsafe_set: t => int => elt => unit;

let buffer: t => array_buffer;

let byteLength: t => int;

let byteOffset: t => int;

let setArray: array(elt) => t => unit;

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

let length: t => int;

let copyWithin: to_:int => ?start:int => ?end_:int => t => t;

let fill: elt => ?start:int => ?end_:int => t => t;

let reverseInPlace: t => t;

let sortInPlace: t => t;

let sortInPlaceWith: f:(elt => elt => int) => t => t;

let includes: value:elt => t => bool;

let indexOf: value:elt => ?start:int => t => int;

let join: ?sep:string => t => string;

let lastIndexOf: value:elt => t => int;

let lastIndexOfFrom: value:elt => from:int => t => int;

let slice: ?start:int => ?end_:int => t => t;

start is inclusive, end_ exclusive

let copy: t => t;

let subarray: ?start:int => ?end_:int => t => t;

start is inclusive, end_ exclusive

let toString: t => string;

let toLocaleString: t => string;

let entries: t => Js.iterator((int, elt));

let every: f:(elt => bool) => t => bool;

let everyi: f:(elt => int => bool) => t => bool;

let filter: f:(elt => bool) => t => t;

let filteri: f:(elt => int => bool) => t => t;

let find: f:(elt => bool) => t => Js.undefined(elt);

let findi: f:(elt => int => bool) => t => Js.undefined(elt);

let findIndex: f:(elt => bool) => t => int;

let findIndexi: f:(elt => int => bool) => t => int;

let forEach: f:(elt => unit) => t => unit;

let forEachi: f:(elt => int => unit) => t => unit;

let keys: t => Js.iterator(int);

let map: f:(elt => 'b) => t => typed_array('b);

let mapi: f:(elt => int => 'b) => t => typed_array('b);

let reduce: f:('b => elt => 'b) => init:'b => t => 'b;

let reducei: f:('b => elt => int => 'b) => init:'b => t => 'b;

let reduceRight: f:('b => elt => 'b) => init:'b => t => 'b;

let reduceRighti: f:('b => elt => int => 'b) => init:'b => t => 'b;

let some: f:(elt => bool) => t => bool;

let somei: f:(elt => int => bool) => t => bool;

let _BYTES_PER_ELEMENT: int;

let make: array(elt) => t;

let fromBuffer: array_buffer => ?off:int => ?len:int => unit => t;

raises Js.Exn.Error
raises Js exception

parameter offset
is in bytes, length in elements

let fromLength: int => t;

let from: Js.array_like(elt) => t;

let values: t => Js.iterator(elt);