LinQ for TypeScript

Install

$ npm i linqts

Usage

import { List } from 'linqts';

const arr = new List<number>([1, 2, 3, 4, 5])
  .Where(x => x > 3)
  .Select(y => y * 2)
  .ToArray(); // > [8, 10]

const query = people.Join(pets,
  person => person,
  pet => pet.Owner,
  (person, pet) =>
    ({ OwnerName: person.Name, Pet: pet.Name }));

Extending List<T>

Type-preserving operators (Where, Take, Skip, Distinct, Concat, Reverse, etc.) return the type of the receiver, so subclasses keep their derived type and fluent chaining just works:

class UserList extends List<User> {
  public Active(): this {
    return this.Where(user => user.Active);
  }
}

const users = new UserList(seedUsers);
users.Active().Take(10); // still a UserList ✨

New instances are created through a protected cloneWith(elements: T[]): this factory that calls the receiver's constructor with the elements array. If your subclass constructor has a different signature, override it:

class TaggedList extends List<number> {
  constructor(public Tag: string, elements: number[] = []) {
    super(elements);
  }

  protected cloneWith(elements: number[]): this {
    return new TaggedList(this.Tag, elements) as this;
  }
}

Projection operators that change the element type (Select, SelectMany, Cast, OfType, GroupBy, Join, Zip...) still return a plain List<TOut>, since a derived list of a different element type would be meaningless.

Demo

Documentation

If you do not know LinQ or just want to remember what is all about, have a look at the docs.

Tests

$ npm t

Powered by AVA.

Contributors

Thanks goes to these wonderful people (emoji key):

This project follows the all-contributors specification. Contributions of any kind welcome!

License

MIT © Flavio Corpa