Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Vector<T>

A general-purpose list class with all-around good performance. quasi-O(1) (actually O(log32(n))) access, append, replace. It's backed by a bit-mapped vector trie.

Type parameters

  • T

    the item type

Hierarchy

  • Vector

Implements

Index

Methods

Static empty

  • The empty vector.

    Type parameters

    • T

      the item type

    Returns Vector<T>

Static isEmpty

  • isEmpty<T>(v: Vector<T>): boolean
  • Curried predicate to find out whether the vector is empty.

    LinkedList.of(Vector.of(1), Vector.empty<number>())
        .filter(Vector.isEmpty)
    => LinkedList.of(Vector.empty<number>())
    

    Type parameters

    • T

    Parameters

    Returns boolean

Static isNotEmpty

  • isNotEmpty<T>(v: Vector<T>): boolean
  • Curried predicate to find out whether the vector is empty.

    LinkedList.of(Vector.of(1), Vector.empty<number>())
        .filter(Vector.isNotEmpty)
    => LinkedList.of(Vector.of(1))
    

    Type parameters

    • T

    Parameters

    Returns boolean

Static of

  • of<T>(...data: T[]): Vector<T>
  • Build a vector from a series of items (any number, as parameters)

    Type parameters

    • T

      the item type

    Parameters

    • Rest ...data: T[]

    Returns Vector<T>

Static ofIterable

  • ofIterable<T>(elts: Iterable<T>): Vector<T>
  • Build a vector from any iterable, which means also an array for instance.

    Type parameters

    • T

      the item type

    Parameters

    • elts: Iterable<T>

    Returns Vector<T>

Static unfoldRight

  • unfoldRight<T, U>(seed: T, fn: function): Vector<U>
  • Dual to the foldRight function. Build a collection from a seed. Takes a starting element and a function. It applies the function on the starting element; if the function returns None, it stops building the list, if it returns Some of a pair, it adds the first element to the result and takes the second element as a seed to keep going.

    Vector.unfoldRight(
         10, x=>Option.of(x)
             .filter(x => x!==0)
             .map<[number,number]>(x => [x,x-1]))
    => Vector.of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
    

    Type parameters

    • T

    • U

    Parameters

    • seed: T
    • fn: function
        • Parameters

          • x: T

          Returns Option<[U, T]>

    Returns Vector<U>

Static zip

  • Combine any number of iterables you give in as parameters to produce a new collection which combines all, in tuples. For instance:

    Vector.zip(Vector.of(1,2,3), ["a","b","c"], LinkedList.of(8,9,10))
    => Vector.of([1,"a",8], [2,"b",9], [3,"c",10])
    

    The result collection will have the length of the shorter of the input iterables. Extra elements will be discarded.

    Also see the non-static version, which only combines two collections.

    Type parameters

    • A: any[]

      A is the type of the tuple that'll be generated ([number,string,number] for the code sample)

    Parameters

    Returns Vector<A>

__@iterator

  • __@iterator(): Iterator<T>

__computed

  • __computed(): string
  • Used by the node REPL to display values. Most of the time should be the same as toString()

    Returns string

allMatch

  • allMatch(predicate: function): boolean
  • Returns true if the predicate returns true for all the elements in the collection.

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns boolean

anyMatch

  • anyMatch(predicate: function): boolean
  • Returns true if there the predicate returns true for any element in the collection.

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns boolean

append

appendAll

  • appendAll(elts: Iterable<T>): Vector<T>
  • Append multiple elements at the end of the collection. Note that arrays are also iterables.

    Parameters

    • elts: Iterable<T>

    Returns Vector<T>

arrangeBy

  • Matches each element with a unique key that you extract from it. If the same key is present twice, the function will return None.

    also see Vector.groupBy

    Type parameters

    • K

    Parameters

    Returns Option<HashMap<K, T>>

contains

distinctBy

  • distinctBy<U>(keyExtractor: function): Vector<T>
  • Remove duplicate items; elements are mapped to keys, those get compared.

    Vector.of(1,1,2,3,2,3,1).distinctBy(x => x);
    => Vector.of(1,2,3)
    

    Type parameters

    • U

    Parameters

    Returns Vector<T>

drop

  • Returns a new collection with the first n elements discarded. If the collection has less than n elements, returns the empty collection.

    Parameters

    • n: number

    Returns Vector<T>

dropRight

  • dropRight(n: number): Vector<T>
  • Returns a new collection with the last n elements discarded. If the collection has less than n elements, returns the empty collection.

    Parameters

    • n: number

    Returns Vector<T>

dropRightWhile

  • dropRightWhile(predicate: function): Vector<T>
  • Returns a new collection, discarding the last elements until one element fails the predicate. All elements before that point are retained.

    Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns Vector<T>

dropWhile

  • dropWhile(predicate: function): Vector<T>
  • Returns a new collection, discarding the first elements until one element fails the predicate. All elements after that point are retained.

    Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns Vector<T>

equals

  • Two objects are equal if they represent the same value, regardless of whether they are the same object physically in memory.

    Parameters

    Returns boolean

filter

  • filter<U>(fun: function): Vector<U>
  • filter(fun: function): Vector<T>
  • Call a predicate for each element in the collection, build a new collection holding only the elements for which the predicate returned true.

    Type parameters

    • U: T

    Parameters

    • fun: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Vector<U>

  • Parameters

    • fun: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Vector<T>

find

  • find(predicate: function): Option<T>
  • Search for the first item matching the predicate you pass, return Option.Some of that element if found, Option.None otherwise.

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Option<T>

findIndex

  • findIndex(predicate: function): Option<number>
  • Search for the first item matching the predicate you pass, returning its index in the form of Option.Some if found, Option.None otherwise.

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Option<number>

findLast

  • findLast(predicate: function): Option<T>
  • Search for the last item matching the predicate you pass, return Option.Some of that element if found, Option.None otherwise.

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Option<T>

flatMap

  • flatMap<U>(mapper: function): Vector<U>
  • Calls the function you give for each item in the collection, your function returns a collection, all the collections are concatenated. This is the monadic bind.

    Type parameters

    • U

    Parameters

    • mapper: function

    Returns Vector<U>

fold

  • fold(zero: T, fn: function): T
  • Reduces the collection to a single value using the associative binary function you give. Since the function is associative, order of application doesn't matter.

    Example:

    Vector.of(1,2,3).fold(0, (a,b) => a + b);
    => 6
    

    Parameters

    • zero: T
    • fn: function
        • (v1: T, v2: T): T
        • Parameters

          • v1: T
          • v2: T

          Returns T

    Returns T

foldLeft

  • foldLeft<U>(zero: U, fn: function): U
  • Reduces the collection to a single value. Left-associative.

    Example:

    Vector.of("a", "b", "c").foldLeft("!", (xs,x) => x+xs);
    => "cba!"
    

    Type parameters

    • U

    Parameters

    • zero: U

      The initial value

    • fn: function

      A function taking the previous value and the current collection item, and returning an updated value.

        • (soFar: U, cur: T): U
        • Parameters

          • soFar: U
          • cur: T

          Returns U

    Returns U

foldRight

  • foldRight<U>(zero: U, fn: function): U
  • Reduces the collection to a single value. Right-associative.

    Example:

    Vector.of("a", "b", "c").foldRight("!", (x,xs) => xs+x);
    => "!cba"
    

    Type parameters

    • U

    Parameters

    • zero: U

      The initial value

    • fn: function

      A function taking the current collection item and the previous value , and returning an updated value.

        • (cur: T, soFar: U): U
        • Parameters

          • cur: T
          • soFar: U

          Returns U

    Returns U

forEach

  • forEach(fun: function): Vector<T>
  • Call a function for element in the collection.

    Parameters

    • fun: function
        • (x: T): void
        • Parameters

          • x: T

          Returns void

    Returns Vector<T>

get

  • get(index: number): Option<T>
  • Retrieve the element at index idx. Returns an option because the collection may contain less elements than the index.

    Parameters

    • index: number

    Returns Option<T>

groupBy

  • Group elements in the collection using a classifier function. Elements are then organized in a map. The key is the value of the classifier, and in value we get the list of elements matching that value.

    also see Vector.arrangeBy

    Type parameters

    • C

    Parameters

    Returns HashMap<C, Vector<T>>

hashCode

  • hashCode(): number
  • Get a number for that object. Two different values may get the same number, but one value must always get the same number. The formula can impact performance.

    Returns number

head

  • Get the first value of the collection, if any. returns Option.Some if the collection is not empty, Option.None if it's empty.

    Returns Option<T>

indexOf

  • Returns the index of the first occurence of the value you give, if present

    Vector.of(1, 2, 3, 4, 3).indexOf(3)
    => Option.of(2)
    

    Parameters

    Returns Option<number>

init

  • Return a new vector containing all the elements in this vector except the last one, or the empty vector if this is the empty vector.

    Vector.of(1,2,3).init()
    => Vector.of(1,2)
    

    Returns Vector<T>

isEmpty

  • isEmpty(): boolean
  • true if the collection is empty, false otherwise.

    Returns boolean

last

  • Get the last value of the collection, if any. returns Option.Some if the collection is not empty, Option.None if it's empty.

    Returns Option<T>

length

  • length(): number

map

  • map<U>(fun: function): Vector<U>
  • Return a new collection where each element was transformed by the mapper function you give.

    Type parameters

    • U

    Parameters

    • fun: function
        • (x: T): U
        • Parameters

          • x: T

          Returns U

    Returns Vector<U>

mapOption

  • mapOption<U>(mapper: function): Vector<U>
  • Apply the mapper function on every element of this collection. The mapper function returns an Option; if the Option is a Some, the value it contains is added to the result Collection, if it's a None, the value is discarded.

    Vector.of(1,2,6).mapOption(x => x%2===0 ?
        Option.of(x+1) : Option.none<number>())
    => Vector.of(3, 7)
    

    Type parameters

    • U

    Parameters

    • mapper: function

    Returns Vector<U>

maxBy

  • maxBy(compare: function): Option<T>
  • Compare values in the collection and return the largest element. Returns Option.none if the collection is empty.

    also see Vector.maxOn

    Parameters

    • compare: function

    Returns Option<T>

maxOn

  • Call the function you give for each value in the collection and return the element for which the result was the largest. Returns Option.none if the collection is empty.

    Vector.of({name:"Joe", age:12}, {name:"Paula", age:6}).maxOn(x=>x.age)
    => Option.of({name:"Joe", age:12})
    

    also see Vector.maxBy

    Parameters

    Returns Option<T>

minBy

  • minBy(compare: function): Option<T>
  • Compare values in the collection and return the smallest element. Returns Option.none if the collection is empty.

    also see Vector.minOn

    Parameters

    • compare: function

    Returns Option<T>

minOn

  • Call the function you give for each value in the collection and return the element for which the result was the smallest. Returns Option.none if the collection is empty.

    Vector.of({name:"Joe", age:12}, {name:"Paula", age:6}).minOn(x=>x.age)
    => Option.of({name:"Paula", age:6})
    

    also see Vector.minBy

    Parameters

    Returns Option<T>

mkString

  • mkString(separator: string): string
  • Joins elements of the collection by a separator. Example:

    Vector.of(1,2,3).mkString(", ")
    => "1, 2, 3"
    

    Parameters

    • separator: string

    Returns string

partition

  • partition<U>(predicate: function): [Vector<U>, Vector<Exclude<T, U>>]
  • partition(predicate: function): [Vector<T>, Vector<T>]
  • Returns a pair of two collections; the first one will only contain the items from this collection for which the predicate you give returns true, the second will only contain the items from this collection where the predicate returns false.

    Vector.of(1,2,3,4).partition(x => x%2===0)
    => [Vector.of(2,4),Vector.of(1,3)]
    

    Type parameters

    • U: T

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns [Vector<U>, Vector<Exclude<T, U>>]

  • Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns [Vector<T>, Vector<T>]

prepend

  • Prepend an element at the beginning of the collection.

    Parameters

    • elt: T

    Returns Vector<T>

prependAll

  • prependAll(elts: Iterable<T>): Vector<T>
  • Prepend multiple elements at the beginning of the collection.

    Parameters

    • elts: Iterable<T>

    Returns Vector<T>

reduce

  • reduce(combine: function): Option<T>
  • Reduces the collection to a single value by repeatedly calling the combine function. No starting value. The order in which the elements are passed to the combining function is undetermined.

    Parameters

    • combine: function
        • (v1: T, v2: T): T
        • Parameters

          • v1: T
          • v2: T

          Returns T

    Returns Option<T>

removeAll

  • Remove multiple elements from a vector

    Vector.of(1,2,3,4,3,2,1).removeAll([2,4])
    => Vector.of(1,3,3,1)
    

    Parameters

    Returns Vector<T>

removeFirst

  • removeFirst(predicate: function): Vector<T>
  • Removes the first element matching the predicate (use Seq.filter to remove all elements matching a predicate)

    Parameters

    • predicate: function
        • (v: T): boolean
        • Parameters

          • v: T

          Returns boolean

    Returns Vector<T>

replace

  • replace(index: number, val: T): Vector<T>
  • Replace the value of element at the index you give. Will throw if the index is out of bounds!

    Parameters

    • index: number
    • val: T

    Returns Vector<T>

replaceAll

  • Replace all occurences of the element you give by the new value you give.

    Vector.of(1, 2, 3, 4, 2).replaceAll(2, 5)
    => Vector.of(1, 5, 3, 4, 5)
    

    Parameters

    Returns Vector<T>

replaceFirst

  • Replace the first occurence (if any) of the element you give by the new value you give.

    Vector.of(1, 2, 3, 4, 2).replaceFirst(2, 5)
    => Vector.of(1, 5, 3, 4, 2)
    

    Parameters

    Returns Vector<T>

reverse

  • Reverse the collection. For instance:

    Vector.of(1,2,3).reverse();
    => Vector.of(3,2,1)
    

    Returns Vector<T>

scanLeft

  • scanLeft<U>(init: U, fn: function): Vector<U>
  • Apply the function you give to all elements of the sequence in turn, keeping the intermediate results and returning them along with the final result in a list. The last element of the result is the final cumulative result.

    Vector.of(1,2,3).scanLeft(0, (soFar,cur)=>soFar+cur)
    => Vector.of(0,1,3,6)
    

    Type parameters

    • U

    Parameters

    • init: U
    • fn: function
        • (soFar: U, cur: T): U
        • Parameters

          • soFar: U
          • cur: T

          Returns U

    Returns Vector<U>

scanRight

  • scanRight<U>(init: U, fn: function): Vector<U>
  • Apply the function you give to all elements of the sequence in turn, keeping the intermediate results and returning them along with the final result in a list. The first element of the result is the final cumulative result.

    Vector.of(1,2,3).scanRight(0, (cur,soFar)=>soFar+cur)
    => Vector.of(6,5,3,0)
    

    Type parameters

    • U

    Parameters

    • init: U
    • fn: function
        • (cur: T, soFar: U): U
        • Parameters

          • cur: T
          • soFar: U

          Returns U

    Returns Vector<U>

shuffle

single

  • If the collection contains a single element, return Some of its value, otherwise return None.

    Returns Option<T>

sliding

  • Slides a window of a specific size over the sequence. Returns a lazy stream so memory use is not prohibitive.

    Vector.of(1,2,3,4,5,6,7,8).sliding(3)
    => Stream.of(Vector.of(1,2,3), Vector.of(4,5,6), Vector.of(7,8))
    

    Parameters

    • count: number

    Returns Stream<Vector<T>>

sortBy

  • sortBy(compare: function): Vector<T>
  • Returns a new collection with elements sorted according to the comparator you give.

    also see Vector.sortOn

    Parameters

    • compare: function

    Returns Vector<T>

sortOn

  • Give a function associating a number or a string with elements from the collection, and the elements are sorted according to that value.

    Vector.of({a:3,b:"b"},{a:1,b:"test"},{a:2,b:"a"}).sortOn(elt=>elt.a)
    => Vector.of({a:1,b:"test"},{a:2,b:"a"},{a:3,b:"b"})
    

    You can also sort by multiple criteria, and request 'descending' sorting:

    Vector.of({a:1,b:"b"},{a:1,b:"test"},{a:2,b:"a"}).sortOn(elt=>elt.a,{desc:elt=>elt.b})
    => Vector.of({a:1,b:"test"},{a:1,b:"b"},{a:2,b:"a"})
    

    also see Vector.sortBy

    Parameters

    Returns Vector<T>

span

  • Takes a predicate; returns a pair of collections. The first one is the longest prefix of this collection which satisfies the predicate, and the second collection is the remainder of the collection.

    Vector.of(1,2,3,4,5,6).span(x => x <3) => [Vector.of(1,2), Vector.of(3,4,5,6)]

    Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns [Vector<T>, Vector<T>]

splitAt

  • Split the collection at a specific index.

    Vector.of(1,2,3,4,5).splitAt(3)
    => [Vector.of(1,2,3), Vector.of(4,5)]
    

    Parameters

    • index: number

    Returns [Vector<T>, Vector<T>]

sumOn

  • sumOn(getNumber: function): number
  • Call the function you give for each element in the collection and sum all the numbers, return that sum. Will return 0 if the collection is empty.

    Vector.of(1,2,3).sumOn(x=>x)
    => 6
    

    Parameters

    • getNumber: function
        • (v: T): number
        • Parameters

          • v: T

          Returns number

    Returns number

tail

  • Get all the elements in the collection but the first one. If the collection is empty, return None.

    Returns Option<Vector<T>>

take

  • Return a new collection containing the first n elements from this collection

    Vector.of(1,2,3,4).take(2)
    => Vector.of(1,2)
    

    Parameters

    • n: number

    Returns Vector<T>

takeRightWhile

  • takeRightWhile(predicate: function): Vector<T>
  • Returns a new collection, discarding the elements after the first element which fails the predicate, but starting from the end of the collection.

    Vector.of(1,2,3,4).takeRightWhile(x => x > 2)
    => Vector.of(3,4)
    

    Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns Vector<T>

takeWhile

  • takeWhile(predicate: function): Vector<T>
  • Returns a new collection, discarding the elements after the first element which fails the predicate.

    Parameters

    • predicate: function
        • (x: T): boolean
        • Parameters

          • x: T

          Returns boolean

    Returns Vector<T>

toArray

  • toArray(): T[]

toMap

  • toMap<K, V>(converter: function): HashMap<K, V>
  • Convert this collection to a map. You give a function which for each element in the collection returns a pair. The key of the pair will be used as a key in the map, the value, as a value in the map. If several values get the same key, entries will be lost.

    Vector.of(1,2,3).toMap(x=>[x.toString(), x])
    => HashMap.of(["1",1], ["2",2], ["3",3])
    

    Type parameters

    • K

    • V

    Parameters

    Returns HashMap<K, V>

toSet

  • toSet<K>(converter: function): HashSet<K>
  • Convert this collection to a set. Since the elements of the Seq may not support equality, you must pass a function returning a value supporting equality.

    Vector.of(1,2,3,3,4).toSet(x=>x)
    => HashSet.of(1,2,3,4)
    

    Type parameters

    • K

    Parameters

    Returns HashSet<K>

toString

  • toString(): string

transform

  • transform<U>(converter: function): U
  • Transform this value to another value type. Enables fluent-style programming by chaining calls.

    Type parameters

    • U

    Parameters

    • converter: function

    Returns U

zip

  • zip<U>(other: Iterable<U>): Vector<[T, U]>
  • Combine this collection with the collection you give in parameter to produce a new collection which combines both, in pairs. For instance:

    Vector.of(1,2,3).zip(["a","b","c"])
    => Vector.of([1,"a"], [2,"b"], [3,"c"])
    

    The result collection will have the length of the shorter of both collections. Extra elements will be discarded.

    Also see Vector.zip (static version which can more than two iterables)

    Type parameters

    • U

    Parameters

    • other: Iterable<U>

    Returns Vector<[T, U]>

zipWithIndex

  • zipWithIndex(): Vector<[T, number]>
  • Combine this collection with the index of the elements in it. Handy if you need the index when you map on the collection for instance:

    Vector.of("a","b").zipWithIndex().map(([v,idx]) => v+idx)
    => Vector.of("a0", "b1")
    

    Returns Vector<[T, number]>

Generated using TypeDoc