Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Collection<T>

Type parameters

  • T

Hierarchy

Index

Methods

__@iterator

  • __@iterator(): Iterator<T>
  • Returns 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

arrangeBy

contains

  • Returns true if the item is in the collection, false otherwise.

    Parameters

    Returns boolean

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

  • 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

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

          • v: T

          Returns boolean

    Returns Collection<U>

  • Parameters

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

          • v: T

          Returns boolean

    Returns Collection<T>

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:

    HashSet.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

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 Collection.arrangeBy

    Type parameters

    • C

    Parameters

    Returns HashMap<C, Collection<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

isEmpty

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

    Returns boolean

length

  • length(): number

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 Collection.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 Collection.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 Collection.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 Collection.minBy

    Parameters

    Returns Option<T>

partition

  • 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 [Collection<U>, Collection<Exclude<T, U>>]

  • Parameters

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

          • x: T

          Returns boolean

    Returns [Collection<T>, Collection<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>

single

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

    Returns Option<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

toArray

  • toArray(): Array<T>

toString

  • toString(): string
  • Get a human-friendly string representation of that value.

    Returns string

Generated using TypeDoc