Zafu/Collection/Vector

source code:

• src/Zafu/Collection/Vector.bosatsu

public dependencies: Zafu/Abstract/Eq, Zafu/Abstract/Foldable, Zafu/Abstract/Hash, Zafu/Abstract/Monoid, Zafu/Abstract/Ord, Zafu/Abstract/Semigroup, Zafu/Abstract/Traverse

Index

• Types: Vector
• Values: append, combine_all, combine_all_option, concat, concat_all, drop, empty, eq_Vector, filter, flat_map, foldable_Vector, foldl, foldr, from_List, get_or, hash_Vector, index, map, ord_Vector, prepend, size, slice, split, split_at, take, to_List, traverse_Vector, updated, zip

Types

Vector[a]

Persistent vector backed by an RRB-style tree.

type Vector[a: +*]

Values

append

Appends a single element to the end of a vector.

references: Vector

def append[a](vec: Vector[a], item: a) -> Vector[a]

combine_all

references: Vector, Zafu/Abstract/Monoid::Monoid

def combine_all[a](vec: Vector[a], monoid: Zafu/Abstract/Monoid::Monoid[a]) -> a

combine_all_option

references: Option, Vector, Zafu/Abstract/Semigroup::Semigroup

def combine_all_option[a](vec: Vector[a], semi: Zafu/Abstract/Semigroup::Semigroup[a]) -> Option[a]

concat

Concatenates two vectors.

references: Vector

def concat[a](left: Vector[a], right: Vector[a]) -> Vector[a]

concat_all

Concatenates all vectors in a list from left to right.

references: List, Vector

def concat_all[a](vecs: List[Vector[a]]) -> Vector[a]

drop

Drops the first count elements.

references: Int, Vector

def drop[a](vec: Vector[a], count: Int) -> Vector[a]

empty

The empty vector.

references: Vector

empty: forall a: *. Vector[a]

eq_Vector

references: Vector, Zafu/Abstract/Eq::Eq

def eq_Vector[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[Vector[a]]

filter

Keeps elements that satisfy a predicate.

references: Bool, Vector

def filter[a](vec: Vector[a], pred: a -> Bool) -> Vector[a]

flat_map

Maps each element to a vector and concatenates the results.

references: Vector

def flat_map[a, b](vec: Vector[a], fn: a -> Vector[b]) -> Vector[b]

foldable_Vector

references: Vector, Zafu/Abstract/Foldable::Foldable

foldable_Vector: Zafu/Abstract/Foldable::Foldable[Vector]

foldl

Left fold over all vector elements.

references: Vector

def foldl[a, b](vec: Vector[a], init: b, fn: (b, a) -> b) -> b

foldr

Right fold over all vector elements.

references: Vector

def foldr[a, b](vec: Vector[a], init: b, fn: (a, b) -> b) -> b

from_List

Builds a vector from a list while preserving order.

references: List, Vector

def from_List[a](list: List[a]) -> Vector[a]

get_or

Returns the element at an index, or calls fn when out of bounds.

references: Int, Unit, Vector

def get_or[a](vec: Vector[a], idx: Int, fn: () -> a) -> a

hash_Vector

references: Vector, Zafu/Abstract/Hash::Hash

def hash_Vector[a](hash_item: Zafu/Abstract/Hash::Hash[a]) -> Zafu/Abstract/Hash::Hash[Vector[a]]

index

Returns the element at an index when it is in bounds.

references: Int, Option, Vector

def index[a](vec: Vector[a], idx: Int) -> Option[a]

map

Maps each element to a new vector while preserving tree shape.

references: Vector

def map[a, b](vec: Vector[a], fn: a -> b) -> Vector[b]

ord_Vector

references: Vector, Zafu/Abstract/Ord::Ord

def ord_Vector[a](ord_item: Zafu/Abstract/Ord::Ord[a]) -> Zafu/Abstract/Ord::Ord[Vector[a]]

prepend

Prepends a single element to the front of a vector.

references: Vector

def prepend[a](vec: Vector[a], item: a) -> Vector[a]

size

Returns the number of elements in a vector.

references: Int, Vector

def size[a](vec: Vector[a]) -> Int

slice

Returns a slice in the half-open interval [start, end).

references: Int, Vector

def slice[a](vec: Vector[a], start: Int, end: Int) -> Vector[a]

split

Backward-compatible alias for split_at.

references: Int, Tuple2, Vector

def split[a](vec: Vector[a], count: Int) -> (Vector[a], Vector[a])

split_at

Splits at count into (take count, drop count).

references: Int, Tuple2, Vector

def split_at[a](vec: Vector[a], count: Int) -> (Vector[a], Vector[a])

take

Takes the first count elements.

references: Int, Vector

def take[a](vec: Vector[a], count: Int) -> Vector[a]

to_List

Converts a vector to a list in element order.

references: List, Vector

def to_List[a](vec: Vector[a]) -> List[a]

traverse_Vector

references: Vector, Zafu/Abstract/Traverse::Traverse

traverse_Vector: Zafu/Abstract/Traverse::Traverse[Vector]

updated

Replaces the element at idx when in bounds.

references: Int, Vector

def updated[a](vec: Vector[a], idx: Int, item: a) -> Vector[a]

zip

Zips two vectors to the shorter length.

references: Tuple2, Vector

def zip[a, b](left: Vector[a], right: Vector[b]) -> Vector[(a, b)]