Type Vecpub

Implements: Chainable · Default · Filterable · Foldable · Indexed · Mappable · Matcher · Matcher · Zippable

:type(pub) Vec

Trait Implementations

impl Chainable for Vec(`?540812` `?540813`)

.chain ( (Vec elem len) (Vec elem len) → (Vec elem len) )

impl Default for Vec(`?490380` `?490381`)

.default ( → (Vec elem len) )

impl Filterable for Vec(`?540792` `?540793`) | Vec(`?540792` `?540793`)

.filter ( (Vec elem len) [elem → Bool ] → (Vec elem len) )

impl Foldable for Vec(`?540398` `?540399`)

.all ( (Vec elem len) [elem → Bool ] → Bool )

.any ( (Vec elem len) [elem → Bool ] → Bool )

.chunks-n ( (Vec elem) (Int ..) → (Vec (Vec elem)) )

Vec-specific chunks-n: Pair(completed_chunks, current_chunk) accumulator; finaliser flushes any non-empty trailing chunk.

.count ( (Vec elem len) → (Int ..) )

.count-where ( (Vec elem len) [elem → Bool ] → (Int ..) )

.enumerate ( (Vec elem len) → (Pair (Int ..) (Vec (Pair (Int ..) elem))) )

.filter-map ( (Vec elem len) [elem → (Option b) ] → (Vec b) )

.find ( (Vec elem len) [elem → Bool ] → (Option elem) )

.find-map ( (Vec elem len) [elem → (Option b) ] → (Option b) )

.first ( (Vec elem len) → (Option elem) )

.flat-map ( (Vec elem) [elem → (Vec b) ] → (Vec b) )

Vec-specific flat-map: call f per element, flatten the results.

.flatten ( (Vec (Vec inner-elem)) → (Vec inner-elem) )

Vec-specific flatten: nested fold pushing inner Vec's elements into the outer accumulator. Element type is concretely Vec-shaped here, so .push on the accumulator resolves.

.fold ( (Vec elem len) acc [acc elem → acc ] → acc )

.for-each ( (Vec elem len) [elem → ] → )

.intersperse ( (Vec elem len) elem → (Vec elem) )

.is-partitioned ( (Vec elem len) [elem → Bool ] → Bool )

.last ( (Vec elem len) → (Option elem) )

.map-while ( (Vec elem len) [elem → (Option b) ] → (Vec b) )

.max-by ( (Vec elem len) [elem elem → Ordering ] → (Option elem) )

.max-by-key ( (Vec elem len) [elem → key ] → (Option elem) )

.min-by ( (Vec elem len) [elem elem → Ordering ] → (Option elem) )

.min-by-key ( (Vec elem len) [elem → key ] → (Option elem) )

.partition ( (Vec elem len) [elem → Bool ] → (Vec elem la) (Vec elem lb) )

.position ( (Vec elem len) [elem → Bool ] → (Option (Int ..)) )

.reduce ( (Vec elem len) [elem elem → elem ] → (Option elem) )

.rposition ( (Vec elem len) [elem → Bool ] → (Option (Int ..)) )

.scan ( (Vec elem len) state [state elem → state (Option result) ] → (Vec result) )

.skip ( (Vec elem len) (Int ..) → (Vec elem) )

.skip-while ( (Vec elem len) [elem → Bool ] → (Vec elem) )

.step-by ( (Vec elem len) (Int ..) → (Vec elem) )

.take ( (Vec elem len) (Int ..) → (Vec elem) )

.take-while ( (Vec elem len) [elem → Bool ] → (Vec elem) )

.try-fold ( (Vec elem len) acc [acc elem → (Result acc err) ] → (Result acc err) )

.try-for-each ( (Vec elem len) [elem → (Result Unit err) ] → (Result Unit err) )

.try-reduce ( (Vec elem len) [elem elem → (Result elem err) ] → (Result (Option elem) err) )

.unzip ( (Vec (Pair a b)) → (Pair (Vec a) (Vec b)) )

Vec-specific unzip: each element's .a / .b go onto matching Vecs.

impl Indexed for Vec(`?540821` `?540822`)

.at ( (Int ..) (Vec elem len) → (Option elem) )

.size ( (Vec elem len) → (Int ..) )

impl Mappable for Vec(`?540781` `?540782`) | Vec(`?540783` `?540782`)

.map ( (Vec a len) [a → b ] → (Vec b len) )

impl Matcher Vec(Int(..)) Int(..) for Vec(Int(..))

.find-all-in ( (Vec (Int ..)) (Vec (Int ..)) → (Vec (Range (Int ..))) )

.find-in ( (Vec (Int ..)) (Vec (Int ..)) → (Option (Range (Int ..))) )

impl Matcher Str Codepoint for Vec(Codepoint)

A (Vec Codepoint) is a matcher that matches any codepoint in the set. Walks the haystack by byte offset via str-next-char.

.find-all-in ( (Vec Codepoint) Str → (Vec (Range (Int ..))) )

.find-in ( (Vec Codepoint) Str → (Option (Range (Int ..))) )

impl Zippable for Vec(`?540831` `?540832`)

.zip ( (Vec a la) (Vec b lb) → (Vec (Pair a b) lc) )