std.array

[src]

A dynamically sized contigous sequence.

Types

type Array a = Array a

Values

#[implicit]
let eq ?eq : forall a . [Eq a] -> Eq (Array a)

[src]

Eq a defines equality (==) on a

#[implicit]
let ord ?ord : forall a . [Ord a] -> Ord (Array a)

[src]

Ord a defines an ordering on a

#[implicit]
let show ?d : forall a . [Show a] -> Show (Array a)

[src]

Show a represents a conversion function from a to a readable string.

#[implicit]
let functor : Functor Array

[src]

A Functor represents an action on a parameterized type which does not change the structure with the mapped type.

The following laws should hold:

  • map id == id
  • map (f << g) == map f << map g

#[implicit]
let foldable : Foldable Array

[src]

Operations over a data structure that can be folded which means that a functions gets called on each element to reduce the structure to a single value (Array, List and Map are all Foldable)

#[implicit]
let traversable : Traversable Array

[src] 

#[implicit]
let semigroup : forall a . Semigroup (Array a)

[src]

Semigroup a represents an associative operation on a. This means the following laws must hold:

  • forall x . append x (append y z) == append (append x y) z

#[implicit]
let monoid : forall a . Monoid (Array a)

[src]

Monoid a represents an semigroup an which has an identity. This means the following additional laws must hold:

  • forall x . append x empty == x
  • forall x . append empty x == x

let is_empty array : forall a . Array a -> Bool

[src] 

let len : forall a . Array a -> Int

let index : forall a . Array a -> Int -> a

let append : forall a . Array a -> Array a -> Array a

let slice : forall a . Array a -> Int -> Int -> Array a