gossamer - v6.3.0

gossamer/uint8_array

Types

Uint8Array

</> 
pub type Uint8Array

Values

at

</> 
pub fn at(
  array: Uint8Array,
  index index: Int,
) -> Result(Int, Nil)

buffer

</> 
pub fn buffer(of array: Uint8Array) -> array_buffer.ArrayBuffer

byte_length

</> 
pub fn byte_length(of array: Uint8Array) -> Int

byte_offset

</> 
pub fn byte_offset(of array: Uint8Array) -> Int

copy_within

</> 
pub fn copy_within(
  array: Uint8Array,
  to target: Int,
  from start: Int,
) -> Uint8Array

copy_within_range

</> 
pub fn copy_within_range(
  array: Uint8Array,
  to target: Int,
  from start: Int,
  up_to end: Int,
) -> Uint8Array

entries

</> 
pub fn entries(of array: Uint8Array) -> List(#(Int, Int))

every

</> 
pub fn every(
  in array: Uint8Array,
  satisfying predicate: fn(Int) -> Bool,
) -> Bool

fill

</> 
pub fn fill(array: Uint8Array, with value: Int) -> Uint8Array

fill_range

</> 
pub fn fill_range(
  array: Uint8Array,
  with value: Int,
  from start: Int,
  to end: Int,
) -> Uint8Array

filter

</> 
pub fn filter(
  in array: Uint8Array,
  keeping predicate: fn(Int) -> Bool,
) -> Uint8Array

find

</> 
pub fn find(
  in array: Uint8Array,
  one_that predicate: fn(Int) -> Bool,
) -> Result(Int, Nil)

find_index

</> 
pub fn find_index(
  in array: Uint8Array,
  one_that predicate: fn(Int) -> Bool,
) -> Int

find_last

</> 
pub fn find_last(
  in array: Uint8Array,
  one_that predicate: fn(Int) -> Bool,
) -> Result(Int, Nil)

find_last_index

</> 
pub fn find_last_index(
  in array: Uint8Array,
  one_that predicate: fn(Int) -> Bool,
) -> Int

for_each

</> 
pub fn for_each(
  in array: Uint8Array,
  run callback: fn(Int) -> b,
) -> Nil

from_base64

</> 
pub fn from_base64(string: String) -> Uint8Array

from_buffer

</> 
pub fn from_buffer(
  buffer: array_buffer.ArrayBuffer,
) -> Uint8Array

from_hex

</> 
pub fn from_hex(string: String) -> Uint8Array

from_length

</> 
pub fn from_length(length: Int) -> Uint8Array

from_list

</> 
pub fn from_list(list: List(Int)) -> Uint8Array

from_list_mapped

</> 
pub fn from_list_mapped(
  list: List(a),
  with mapper: fn(a) -> Int,
) -> Uint8Array

includes

</> 
pub fn includes(in array: Uint8Array, value value: Int) -> Bool

includes_from

</> 
pub fn includes_from(
  in array: Uint8Array,
  value value: Int,
  from index: Int,
) -> Bool

index_every

</> 
pub fn index_every(
  in array: Uint8Array,
  satisfying predicate: fn(Int, Int) -> Bool,
) -> Bool

index_filter

</> 
pub fn index_filter(
  in array: Uint8Array,
  keeping predicate: fn(Int, Int) -> Bool,
) -> Uint8Array

index_find

</> 
pub fn index_find(
  in array: Uint8Array,
  one_that predicate: fn(Int, Int) -> Bool,
) -> Result(Int, Nil)

index_find_index

</> 
pub fn index_find_index(
  in array: Uint8Array,
  one_that predicate: fn(Int, Int) -> Bool,
) -> Int

index_find_last

</> 
pub fn index_find_last(
  in array: Uint8Array,
  one_that predicate: fn(Int, Int) -> Bool,
) -> Result(Int, Nil)

index_find_last_index

</> 
pub fn index_find_last_index(
  in array: Uint8Array,
  one_that predicate: fn(Int, Int) -> Bool,
) -> Int

index_for_each

</> 
pub fn index_for_each(
  in array: Uint8Array,
  run callback: fn(Int, Int) -> b,
) -> Nil

index_map

</> 
pub fn index_map(
  over array: Uint8Array,
  with callback: fn(Int, Int) -> Int,
) -> Uint8Array

index_of

</> 
pub fn index_of(in array: Uint8Array, value value: Int) -> Int

index_of_from

</> 
pub fn index_of_from(
  in array: Uint8Array,
  value value: Int,
  from index: Int,
) -> Int

index_reduce

</> 
pub fn index_reduce(
  over array: Uint8Array,
  from initial: a,
  with callback: fn(a, Int, Int) -> a,
) -> a

index_reduce_right

</> 
pub fn index_reduce_right(
  over array: Uint8Array,
  from initial: a,
  with callback: fn(a, Int, Int) -> a,
) -> a

index_some

</> 
pub fn index_some(
  in array: Uint8Array,
  satisfying predicate: fn(Int, Int) -> Bool,
) -> Bool

join

</> 
pub fn join(array: Uint8Array, with separator: String) -> String

keys

</> 
pub fn keys(of array: Uint8Array) -> List(Int)

last_index_of

</> 
pub fn last_index_of(
  in array: Uint8Array,
  value value: Int,
) -> Int

last_index_of_from

</> 
pub fn last_index_of_from(
  in array: Uint8Array,
  value value: Int,
  from index: Int,
) -> Int

length

</> 
pub fn length(of array: Uint8Array) -> Int

map

</> 
pub fn map(
  over array: Uint8Array,
  with callback: fn(Int) -> Int,
) -> Uint8Array

new

</> 
pub fn new() -> Uint8Array

reduce

</> 
pub fn reduce(
  over array: Uint8Array,
  from initial: a,
  with callback: fn(a, Int) -> a,
) -> a

reduce_right

</> 
pub fn reduce_right(
  over array: Uint8Array,
  from initial: a,
  with callback: fn(a, Int) -> a,
) -> a

reverse

</> 
pub fn reverse(array: Uint8Array) -> Uint8Array

set

</> 
pub fn set(
  in array: Uint8Array,
  values values: Uint8Array,
) -> Nil

set_from_base64

</> 
pub fn set_from_base64(
  array: Uint8Array,
  string: String,
) -> #(Int, Int)

set_from_hex

</> 
pub fn set_from_hex(
  array: Uint8Array,
  string: String,
) -> #(Int, Int)

set_with_offset

</> 
pub fn set_with_offset(
  in array: Uint8Array,
  values values: Uint8Array,
  offset offset: Int,
) -> Nil

slice

</> 
pub fn slice(array: Uint8Array) -> Uint8Array

slice_from

</> 
pub fn slice_from(array: Uint8Array, start: Int) -> Uint8Array

slice_range

</> 
pub fn slice_range(
  array: Uint8Array,
  from start: Int,
  to end: Int,
) -> Uint8Array

some

</> 
pub fn some(
  in array: Uint8Array,
  satisfying predicate: fn(Int) -> Bool,
) -> Bool

sort

</> 
pub fn sort(
  array: Uint8Array,
  by compare: fn(Int, Int) -> order.Order,
) -> Uint8Array

subarray

</> 
pub fn subarray(
  array: Uint8Array,
  from begin: Int,
  to end: Int,
) -> Uint8Array

to_base64

</> 
pub fn to_base64(array: Uint8Array) -> String

to_hex

</> 
pub fn to_hex(array: Uint8Array) -> String

to_list

</> 
pub fn to_list(array: Uint8Array) -> List(Int)

to_reversed

</> 
pub fn to_reversed(array: Uint8Array) -> Uint8Array

to_sorted

</> 
pub fn to_sorted(
  array: Uint8Array,
  by compare: fn(Int, Int) -> order.Order,
) -> Uint8Array

values

</> 
pub fn values(of array: Uint8Array) -> List(Int)

with

</> 
pub fn with(
  array: Uint8Array,
  at_index index: Int,
  value value: Int,
) -> Uint8Array
✨ Search Document