Interface ISet<T>

Readonly isReadOnly

Readonly length

add

• add(item): void

• Adds an item to the ICollection.

  Parameters

  • item: T

    The object to add to the ICollection.

  Returns void

all

• all(predicate): boolean

• Returns true if all the items match the predicate, otherwise false

  Parameters

  • predicate: Predicate<T>

  Returns boolean

any

• any(predicate?): boolean

• Returns true if any of the items match the predicate, otherwise false

  Parameters

  • Optional predicate: Predicate<T>

  Returns boolean

  Example

  if (myEnumerable.any()) {
      // do something because the enumerable has elements
  }
  Copy

  let myEnumerable = new ArrayEnumerable([1, 2, 3, 4]);
  if (myEnumerable.any((i) => i == 2)) {
      // the enumerable contains a '2'
  }
  Copy

append

• append(item): IEnumerable<T>

• Adds a value to the end of the sequence.

  Parameters

  • item: T

  Returns IEnumerable<T>

average

• average(selector): number

• Returns the average of the numbers selected by the selector

  Parameters

  • selector: Selector<T, number>

  Returns number

clear

• clear(): void

• Removes all items from the ICollection.

  Returns void

concat

• concat(next): IEnumerable<T>

• Concatenates two sequences.

  Parameters

  • next: IEnumerable<T>

  Returns IEnumerable<T>

contains

• contains(item): boolean

• Determines whether the ICollection contains a specific value.

  Parameters

  • item: T

    The object to locate in the ICollection.

  Returns boolean

copyTo

• copyTo(array, arrayIndex): void

• Copies the elements of the ICollection to an Array, starting at a particular Array index.

  Parameters

  • array: T[]

    The one-dimensional Array that is the destination of the elements copied from ICollection. The Array must have zero-based indexing.

  • arrayIndex: number

    The zero-based index in array at which copying begins.

  Returns void

count

• count(): number

• Returns the number of items in the enumerable

  Returns number

distinct

• distinct<R>(selector): IEnumerable<T>

• Returns the unique items designated by the selector

  Type Parameters

  • R

  Parameters

  • selector: Selector<T, R>

  Returns IEnumerable<T>

first

• first(): T

• Returns the first item in the enumerable

  Returns T
• first(predicate): T

• Returns the first item in the enumerable that matches the predicate

  Parameters

  • predicate: Predicate<T>

  Returns T

firstOrDefault

• firstOrDefault(): null | T

• Returns the first item in the enumerable or null

  Returns null | T
• firstOrDefault(predicate): null | T

• Returns the first item in the enumerable that matches the predicate or null

  Parameters

  • predicate: Predicate<T>

  Returns null | T

forEach

• forEach(callback): void

• Iterates over the enumerable and performs the callback on each item. Return false to break.

  Parameters

  • callback: ((value, index) => boolean | void)

    • • (value, index): boolean | void

      • Parameters

        • value: T

        • index: number

        Returns boolean | void

  Returns void

getEnumerator

• getEnumerator(): IEnumerator<T>

• returns an Enumerator for the items

  Returns IEnumerator<T>

groupBy

• groupBy<TKey>(keySelector): IEnumerable<IEnumerableGroup<T, TKey>>

• Groups the items by the key selector using the default comparer

  Type Parameters

  • TKey

  Parameters

  • keySelector: Selector<T, TKey>

  Returns IEnumerable<IEnumerableGroup<T, TKey>>
• groupBy<TKey>(keySelector, comparer): IEnumerable<IEnumerableGroup<T, TKey>>

• Groups the items by the key selector using the specified comparer

  Type Parameters

  • TKey

  Parameters

  • keySelector: Selector<T, TKey>

  • comparer: IComparer<TKey>

  Returns IEnumerable<IEnumerableGroup<T, TKey>>

item

• item(index): Undefinable<T>

• Returns the item at the specified index

  Parameters

  • index: number

    The index of the item to return

  Returns Undefinable<T>

last

• last(): T

• Returns the last item in the enumerable

  Returns T
• last(predicate): T

• Returns the last item in the enumerable that matches the predicate

  Parameters

  • predicate: Predicate<T>

  Returns T

lastOrDefault

• lastOrDefault(): null | T

• Returns the last item in the enumerable or null

  Returns null | T
• lastOrDefault(predicate): null | T

• Returns the last item in the enumerable that matches the predicate or null

  Parameters

  • predicate: Predicate<T>

  Returns null | T

max

• max(selector): number

• Returns the largest number designated by the selector

  Parameters

  • selector: Selector<T, number>

  Returns number

min

• min(selector): number

• Returns the smallest number designated by the selector

  Parameters

  • selector: Selector<T, number>

  Returns number

ofType

• ofType<N>(ctor): IEnumerable<N>

• Returns an enumerable of items that match the type

  Type Parameters

  • N

  Parameters

  • ctor: ConstructorFor<N>

    the type

  Returns IEnumerable<N>

orderBy

• orderBy<R>(selector, comparer?): IEnumerable<T>

• Orders the enumerable by the the selector and optional comparer ascending

  Type Parameters

  • R

  Parameters

  • selector: Selector<T, R>

  • Optional comparer: IComparer<R>

  Returns IEnumerable<T>

orderByDescending

• orderByDescending<R>(selector, comparer?): IEnumerable<T>

• Orders the enumerable by the the selector and optional comparer descending

  Type Parameters

  • R

  Parameters

  • selector: Selector<T, R>

  • Optional comparer: IComparer<R>

  Returns IEnumerable<T>

prepend

• prepend(item): IEnumerable<T>

• Adds a value to the beginning of the sequence.

  Parameters

  • item: T

  Returns IEnumerable<T>

remove

• remove(item): boolean

• Removes the first occurrence of a specific object from the ICollection.

  Parameters

  • item: T

  Returns boolean

select

• select<TOut>(selector): IEnumerable<TOut>

• Selects the items by the selector

  Type Parameters

  • TOut

  Parameters

  • selector: Selector<T, TOut>

  Returns IEnumerable<TOut>

selectMany

• selectMany<TOut>(selector): IEnumerable<TOut>

• Type Parameters

  • TOut

  Parameters

  • selector: Selector<T, IEnumerable<TOut>>

  Returns IEnumerable<TOut>

single

• single(): T

• Returns a single element only if there is one element in the enumerable

  Returns T

  Throws

  InvalidOperationException if there is not exactly one item in the enumerable

• single(predicate): T

• Returns a single element only if there is one element in the enumerable that matches the predicate

  Parameters

  • predicate: Predicate<T>

  Returns T

  Throws

  InvalidOperationException if there is not exactly one item in the enumerable that matches the predicate

singleOrDefault

• singleOrDefault(): null | T

• Returns a single element only if there is one element in the enumerable. If there are no items in the enumerable, then null is returned

  Returns null | T

  Throws

  InvalidOperationException if there is not exactly one or zero items in the enumerable

• singleOrDefault(predicate): null | T

• Returns a single element only if there is one element in the enumerable that matches the predicate. If there are no items in the enumerable, then null is returned

  Parameters

  • predicate: Predicate<T>

  Returns null | T

  Throws

  InvalidOperationException if there is not exactly one or zero item in the enumerable that matches the predicate

skip

• skip(count): IEnumerable<T>

• Skips the number of items specified. If the count is larger than the size of the enumerable, no items will be returned.

  Parameters

  • count: number

    the number of items to skip

  Returns IEnumerable<T>

split

• split(predicate): {
      pFalse: IEnumerable<T>;
      pTrue: IEnumerable<T>;
  }

• Splits a enumerable into two queryables. One set is for true predicates, the other set is for false predicates.

  Parameters

  • predicate: Predicate<T>

  Returns {
      pFalse: IEnumerable<T>;
      pTrue: IEnumerable<T>;
  }

  • pFalse: IEnumerable<T>

  • pTrue: IEnumerable<T>

sum

• sum(selector): number

• Sums the items in the enumerable using the selector

  Parameters

  • selector: Selector<T, number>

    selector to return the number to be summed

  Returns number

take

• take(count): IEnumerable<T>

• Takes the number of specified items from the enumerable. If the count is larger than the size of the enumerable, all items will be returned

  Parameters

  • count: number

    the number of items to take.

  Returns IEnumerable<T>

toArray

• toArray(): T[]

• Returns the items as an array

  Returns T[]

toDictionary

• toDictionary<TKey, TValue>(keySelector, valueSelector): IDictionary<TKey, TValue>

• Returns a dictionary based on the key and value selctors

  Type Parameters

  • TKey

  • TValue

  Parameters

  • keySelector: ((a) => TKey)

    • • (a): TKey

      • Parameters

        • a: T

        Returns TKey

  • valueSelector: ((a) => TValue)

    • • (a): TValue

      • Parameters

        • a: T

        Returns TValue

  Returns IDictionary<TKey, TValue>

toList

• toList(): IList<T>

• Returns the items as a List

  Returns IList<T>

where

• where(predicate): IEnumerable<T>

• Filters the enumerable by the predicate

  Parameters

  • predicate: Predicate<T>

    the filter for each item.

  Returns IEnumerable<T>