SYMBOL INDEX (894 symbols across 36 files)

FILE: benchmarks/bench.ts
  function getPrerequisites (line 23) | function getPrerequisites(length:number): Prerequisites {
  type Prerequisites (line 62) | interface Prerequisites {
  function _compare (line 83) | function _compare(preReqs: Prerequisites, items: Array<[string, (x:Prere...
  function compare (line 94) | function compare(...items: Array<[string, (x:Prerequisites)=>any]>) {
  function iterateOn (line 266) | function iterateOn<T>(coll: Iterable<T>) {

FILE: scripts/make_doc_extra/classes.ts
  function putStaticMethodsOnTop (line 14) | function putStaticMethodsOnTop(parentTag: string, parentMarker: string, ...
  function classPutStaticMethodsOnTop (line 54) | function classPutStaticMethodsOnTop(classfilename: string): void {
  function putClassStaticMethodsOnTop (line 64) | function putClassStaticMethodsOnTop(): void {

FILE: scripts/make_doc_extra/globals.ts
  constant CATEGORIES (line 8) | const CATEGORIES = Vector.of<[string,Vector<string>]>(
  function getSectionHeader (line 20) | function getSectionHeader(sectionName:string): string {
  function getSectionFooter (line 26) | function getSectionFooter(): string {
  function groupGlobalsByCategory (line 43) | function groupGlobalsByCategory(): void {

FILE: scripts/make_doc_extra/helpers.ts
  function requireNotNull (line 5) | function requireNotNull<T>(x:T|null): T {
  function indent (line 12) | function indent(count: number): string {
  type LineByIndent (line 17) | type LineByIndent = {contents:string,indent:number};
  type LinesByIndent (line 18) | type LinesByIndent = Vector<LineByIndent>;
  function fileGetLinesByIndent (line 20) | function fileGetLinesByIndent(fname: string): LinesByIndent {
  function linesByIndentGetTagContents (line 32) | function linesByIndentGetTagContents(
  function linesByIndentStr (line 50) | function linesByIndentStr(linesByIndent: LinesByIndent): string {

FILE: scripts/make_doc_extra/make_doc_preprocess.ts
  type String (line 4) | interface String {
  function makeModule (line 9) | function makeModule(moduleName:string, filename:string): void {

FILE: src/ChromeDevToolFormatters.ts
  type ElementHandler (line 3) | interface ElementHandler {
  function getWithToArrayBody (line 12) | function getWithToArrayBody(elt: any): any {
  class VectorHandler (line 20) | class VectorHandler implements ElementHandler {
    method isElement (line 21) | isElement(object:any): boolean {
    method getHeader (line 25) | getHeader(object:any): any {
    method hasBody (line 28) | hasBody(elt:any): boolean {
  class StreamHandler (line 35) | class StreamHandler implements ElementHandler {
    method isElement (line 36) | isElement(object:any): boolean {
    method getHeader (line 39) | getHeader(object:any): any {
    method hasBody (line 44) | hasBody(elt:any): boolean {
  class ListHandler (line 50) | class ListHandler implements ElementHandler {
    method isElement (line 51) | isElement(object:any): boolean {
    method getHeader (line 54) | getHeader(object:any): any {
    method hasBody (line 59) | hasBody(elt:any): boolean {
  class HashSetHandler (line 65) | class HashSetHandler implements ElementHandler {
    method isElement (line 66) | isElement(object:any): boolean {
    method getHeader (line 69) | getHeader(object:any): any {
    method hasBody (line 72) | hasBody(elt:any): boolean {
  class HashMapHandler (line 78) | class HashMapHandler implements ElementHandler {
    method isElement (line 79) | isElement(object:any): boolean {
    method getHeader (line 82) | getHeader(object:any): any {
    method hasBody (line 85) | hasBody(elt:any): boolean {
    method getBody (line 88) | getBody(elt:any): any {
  function getHandler (line 109) | function getHandler(object: any): ElementHandler|undefined {

FILE: src/Collection.ts
  type Collection (line 7) | interface Collection<T> extends Value, Iterable<T>, Foldable<T> {

FILE: src/Comparison.ts
  type ToOrderable (line 9) | type ToOrderable<T> = ((v:T)=>number) | ((v:T)=>string) | ((v:T)=>boolean);
  type WithEquality (line 19) | type WithEquality
  type HasEquals (line 29) | type HasEquals = {equals(other: any): boolean; hashCode(): number;};
  function hasEquals (line 36) | function hasEquals(v: WithEquality): v is HasEquals {
  function fieldsHashCode (line 55) | function fieldsHashCode(...fields: any[]): number {
  function stringHashCode (line 68) | function stringHashCode(str: string): number {
  function areEqual (line 84) | function areEqual(obj: any|null, obj2: any|null): boolean {
  function getHashCode (line 103) | function getHashCode(obj: any|null): number {
  function cachedHashString (line 131) | function cachedHashString(string: string) {
  function smi (line 149) | function smi(i32: number): number {
  constant STRING_HASH_CACHE_MIN_STRLEN (line 153) | const STRING_HASH_CACHE_MIN_STRLEN = 16;
  constant STRING_HASH_CACHE_MAX_SIZE (line 154) | const STRING_HASH_CACHE_MAX_SIZE = 255;
  constant STRING_HASH_CACHE_SIZE (line 155) | let STRING_HASH_CACHE_SIZE = 0;
  function hasTrueEquality (line 161) | function hasTrueEquality(val: any): Option<boolean> {
  type Ordering (line 181) | const enum Ordering {
  type TypeGuard (line 208) | type TypeGuard<T,U extends T> = (x: T) => x is U;
  function typeGuard (line 226) | function typeGuard<T,U extends T>(predicate:(x:T)=>boolean,
  function instanceOf (line 248) | function instanceOf<T>(ctor: new(...args: any[]) => T): TypeGuard<any,T> {
  function typeOf (line 274) | function typeOf(typ: string): TypeGuard<any,any> {

FILE: src/Contract.ts
  function setContractViolationAction (line 22) | function setContractViolationAction(action: (msg:string)=>void) {
  function reportContractViolation (line 29) | function reportContractViolation(msg: string): void {
  function contractTrueEquality (line 36) | function contractTrueEquality(context: string, ...vals: Array<any>) {

FILE: src/Either.ts
  class EitherStatic (line 33) | class EitherStatic {
    method left (line 37) | left<L,R>(val: L): Either<L,R> {
    method right (line 44) | right<L,R>(val: R): Either<L,R> {
    method isLeft (line 57) | isLeft<L,R>(e: Either<L,R>): e is Left<L,R> {
    method isRight (line 70) | isRight<L,R>(e: Either<L,R>): e is Right<L,R> {
    method sequence (line 93) | sequence<L,R>(elts:Iterable<Either<L,R>>): Either<L,Vector<R>> {
    method traverse (line 116) | traverse<T,L,R>(elts:Iterable<T>, fn: (x:T)=>Either<L,R>): Either<L,Ve...
    method sequenceAcc (line 149) | sequenceAcc<L,R>(elts:Iterable<Either<L,R>>): Either<Vector<L>,Vector<...
    method liftA2 (line 183) | liftA2<R1,R2,L,V>(fn:(v1:R1,v2:R2)=>V, leftWitness?: L) : (p1:Either<L...
    method liftAp (line 215) | liftAp<L,A,B>(fn:(x:A)=>B, leftWitness?: L): (x: {[K in keyof A]: Eith...
    method liftApAcc (line 259) | liftApAcc<L,A,B>(fn:(x:A)=>B, leftWitness?: L): (x: {[K in keyof A]: E...
    method lift (line 305) | lift<T extends any[],L,U>(fn: (...args: T)=>U, witness?: L): (...args:...
    method try_ (line 345) | try_<L,T>(fn:()=>T, witness?: L): Either<L,T> {
  type Either (line 361) | type Either<L,R> = Left<L,R> | Right<L,R>;
  class Left (line 370) | class Left<L,R> implements Value {
    method constructor (line 371) | constructor(private value: L) {}
    method isLeft (line 381) | isLeft(): this is Left<L,R> {
    method isRight (line 388) | isRight(): this is Right<L,R> {
    method contains (line 395) | contains(val: R&WithEquality): boolean {
    method map (line 403) | map<U>(fn: (x:R)=>U): Either<L,U> {
    method flatMap (line 413) | flatMap<U>(fn: (x:R)=>Either<L,U>): Either<L,U> {
    method mapLeft (line 422) | mapLeft<U>(fn: (x:L)=>U): Either<U,R> {
    method bimap (line 430) | bimap<S,T>(fnL: (x:L)=>S,fnR: (x:R)=>T): Either<S,T> {
    method filter (line 446) | filter(p: (x:R)=>boolean, filterVal: (x:R)=>L): Either<L,R> {
    method orElse (line 454) | orElse(other: Either<L,R>): Either<L,R> {
    method recoverWith (line 464) | recoverWith(recoveryFn: (left:L)=>Either<L, R>): Either<L, R> {
    method ifRight (line 472) | ifRight(fn: (x:R)=>void): Either<L,R> {
    method ifLeft (line 480) | ifLeft(fn: (x:L)=>void): Either<L,R> {
    method match (line 496) | match<U>(cases: {Left: (v:L)=>U, Right: (v:R)=>U}): U {
    method getOrThrow (line 506) | getOrThrow(errorInfo?: Error|string): R {
    method getOrElse (line 517) | getOrElse(other: R): R {
    method getLeft (line 526) | getLeft(): L {
    method getLeftOrThrow (line 536) | getLeftOrThrow(message?: string): L {
    method getLeftOrElse (line 544) | getLeftOrElse(other: L): L {
    method toOption (line 552) | toOption(): Option<R> {
    method toVector (line 561) | toVector(): Vector<R> {
    method toLinkedList (line 570) | toLinkedList(): LinkedList<R> {
    method transform (line 578) | transform<U>(converter:(x:Either<L,R>)=>U): U {
    method hasTrueEquality (line 582) | hasTrueEquality(): boolean {
    method hashCode (line 593) | hashCode(): number {
    method equals (line 602) | equals(other: Either<L&WithEquality,R&WithEquality>): boolean {
    method toString (line 617) | toString(): string {
    method [inspect] (line 624) | [inspect](): string {
  class Right (line 636) | class Right<L,R> implements Value {
    method constructor (line 637) | constructor(private value: R) {}
    method isLeft (line 647) | isLeft(): this is Left<L,R> {
    method isRight (line 654) | isRight(): this is Right<L,R> {
    method contains (line 661) | contains(val: R&WithEquality): boolean {
    method map (line 669) | map<U>(fn: (x:R)=>U): Either<L,U> {
    method flatMap (line 679) | flatMap<U>(fn: (x:R)=>Either<L,U>): Either<L,U> {
    method mapLeft (line 688) | mapLeft<U>(fn: (x:L)=>U): Either<U,R> {
    method bimap (line 696) | bimap<S,T>(fnL: (x:L)=>S,fnR: (x:R)=>T): Either<S,T> {
    method filter (line 712) | filter(p: (x:R)=>boolean, filterVal: (x:R)=>L): Either<L,R> {
    method orElse (line 723) | orElse(other: Either<L,R>): Either<L,R> {
    method recoverWith (line 733) | recoverWith(recoveryFn: (left:L)=>Either<L, R>): Either<L, R> {
    method ifRight (line 741) | ifRight(fn: (x:R)=>void): Either<L,R> {
    method ifLeft (line 750) | ifLeft(fn: (x:L)=>void): Either<L,R> {
    method match (line 765) | match<U>(cases: {Left: (v:L)=>U, Right: (v:R)=>U}): U {
    method get (line 774) | get(): R {
    method getOrThrow (line 784) | getOrThrow(errorInfo?: Error|string): R {
    method getOrElse (line 792) | getOrElse(other: R): R {
    method getLeftOrThrow (line 802) | getLeftOrThrow(message?: string): L {
    method getLeftOrElse (line 810) | getLeftOrElse(other: L): L {
    method toOption (line 818) | toOption(): Option<R> {
    method toVector (line 827) | toVector(): Vector<R> {
    method toLinkedList (line 836) | toLinkedList(): LinkedList<R> {
    method transform (line 844) | transform<U>(converter:(x:Either<L,R>)=>U): U {
    method hasTrueEquality (line 848) | hasTrueEquality(): boolean {
    method hashCode (line 859) | hashCode(): number {
    method equals (line 868) | equals(other: Either<L&WithEquality,R&WithEquality>): boolean {
    method toString (line 883) | toString(): string {
    method [inspect] (line 890) | [inspect](): string {

FILE: src/Foldable.ts
  type Foldable (line 3) | interface Foldable<T> {

FILE: src/Function.ts
  type Function0 (line 29) | interface Function0<R> {
  type Function1 (line 51) | interface Function1<T,U> {
  type Function2 (line 79) | interface Function2<T1,T2,R> {
  type Function3 (line 136) | interface Function3<T1,T2,T3,R> {
  type Function4 (line 199) | interface Function4<T1,T2,T3,T4,R> {
  type Function5 (line 273) | interface Function5<T1,T2,T3,T4,T5,R> {
  class Function0Static (line 353) | class Function0Static {
    method constant (line 360) | constant<R>(val:R): Function0<R> {
    method of (line 368) | of<R>(fn:()=>R): Function0<R> {
  class Function1Static (line 388) | class Function1Static {
    method id (line 393) | id<T>(): Function1<T,T> {
    method constant (line 402) | constant<U,T>(val:T): Function1<U,T> {
    method of (line 410) | of<T,U>(fn:(x:T)=>U): Function1<T,U> {
  class Function2Static (line 431) | class Function2Static {
    method constant (line 437) | constant<T1,T2,R>(val:R): Function2<T1,T2,R> {
    method of (line 445) | of<T1,T2,R>(fn:(x:T1,y:T2)=>R): Function2<T1,T2,R> {
  class Function3Static (line 469) | class Function3Static {
    method constant (line 475) | constant<T1,T2,T3,R>(val:R): Function3<T1,T2,T3,R> {
    method of (line 483) | of<T1,T2,T3,R>(fn:(x:T1,y:T2,z:T3)=>R): Function3<T1,T2,T3,R> {
  class Function4Static (line 508) | class Function4Static {
    method constant (line 515) | constant<T1,T2,T3,T4,R>(val:R): Function4<T1,T2,T3,T4,R> {
    method of (line 523) | of<T1,T2,T3,T4,R>(fn:(x:T1,y:T2,z:T3,a:T4)=>R): Function4<T1,T2,T3,T4,...
  class Function5Static (line 551) | class Function5Static {
    method constant (line 557) | constant<T1,T2,T3,T4,T5,R>(val:R): Function5<T1,T2,T3,T4,T5,R> {
    method of (line 565) | of<T1,T2,T3,T4,T5,R>(fn:(x:T1,y:T2,z:T3,a:T4,b:T5)=>R): Function5<T1,T...

FILE: src/Future.ts
  class Future (line 16) | class Future<T> {
    method constructor (line 23) | private constructor(private promise: Promise<T[]>) { }
    method ofPromiseCtor (line 33) | static ofPromiseCtor<T>(executor: (resolve:(x:T)=>void, reject: (x:any...
    method of (line 40) | static of<T>(promise: Promise<T>): Future<T> {
    method ofCallback (line 49) | static ofCallback<T>(fn: (cb:(err:any, val:T)=>void)=>void): Future<T> {
    method ok (line 62) | static ok<T>(val:T): Future<T> {
    method failed (line 69) | static failed<T>(reason: any): Future<T> {
    method do (line 85) | static do<T>(fn: ()=>Promise<T>): Future<T> {
    method then (line 95) | then<TResult1 = T, TResult2 = never>(
    method toPromise (line 104) | toPromise(): Promise<T> {
    method firstCompletedOf (line 116) | static firstCompletedOf<T>(elts: Iterable<Future<T>>): Future<T> {
    method firstSuccessfulOf (line 128) | static firstSuccessfulOf<T>(elts: Iterable<Future<T>>): Future<T> {
    method sequence (line 156) | static sequence<T>(elts: Iterable<Future<T>>): Future<Vector<T>> {
    method traverse (line 175) | static traverse<T,U>(elts: Iterable<T>, fn: (x:T)=>Future<U>,
    method find (line 225) | static find<T>(elts: Iterable<Future<T>>, p: (x: T) => boolean): Futur...
    method liftAp (line 268) | static liftAp<A,B>(fn:(x:A)=>B): (x: {[K in keyof A]: Future<A[K]>;}) ...
    method liftA2 (line 293) | static liftA2<R1,R2,V>(fn:(v1:R1,v2:R2)=>V) : (p1:Future<R1>, p2:Futur...
    method lift (line 301) | static lift<T extends any[],U>(fn: (...args: T)=>Promise<U>): (...args...
    method map (line 311) | map<U>(fn: (x:T)=>U): Future<U> {
    method flatMap (line 324) | flatMap<U>(fn: (x:T)=>Future<U>): Future<U> {
    method mapFailure (line 332) | mapFailure(fn: (x:any)=>any): Future<T> {
    method onFailure (line 341) | onFailure(fn: (x:any)=>void): Future<T> {
    method onSuccess (line 351) | onSuccess(fn: (x:T)=>void): Future<T> {
    method onComplete (line 365) | onComplete(fn: (x:Either<any,T>)=>void): Future<T> {
    method filter (line 382) | filter(p: (x:T)=>boolean, ifFail: (x:T)=>any): Future<T> {
    method recoverWith (line 393) | recoverWith(f: (err:any)=>Future<T>): Future<T> {
    method transform (line 401) | transform<U>(fn: (x:Future<T>)=>U): U {

FILE: src/HashMap.ts
  class HashMap (line 27) | class HashMap<K,V> implements IMap<K,V> {
    method constructor (line 32) | protected constructor(private hamt: any) {}
    method empty (line 39) | static empty<K,V>(): HashMap<K,V> {
    method of (line 49) | static of<K,V>(...entries: Array<[K&WithEquality, V]>): HashMap<K,V> {
    method ofIterable (line 58) | static ofIterable<K,V>(entries: Iterable<[K&WithEquality, V]>): HashMa...
    method ofObjectDictionary (line 86) | static ofObjectDictionary<V>(object: {[index:string]: V|undefined}): H...
    method isEmpty (line 111) | static isEmpty<K,V>(v: HashMap<K,V>): boolean {
    method isNotEmpty (line 122) | static isNotEmpty<K,V>(v: HashMap<K,V>): boolean {
    method get (line 129) | get(k: K & WithEquality): Option<V> {
    method hasTrueEquality (line 143) | hasTrueEquality(): boolean {
    method put (line 160) | put(k: K & WithEquality, v: V): HashMap<K,V> {
    method remove (line 167) | remove(k: K&WithEquality): HashMap<K,V> {
    method putWithMerge (line 184) | putWithMerge(k: K & WithEquality, v: V, merge: (v1: V, v2: V) => V): H...
    method length (line 196) | length(): number {
    method single (line 204) | single(): Option<[K,V]> {
    method isEmpty (line 213) | isEmpty(): boolean {
    method keySet (line 220) | keySet(): HashSet<K> {
    method valueIterable (line 229) | valueIterable(): Iterable<V> {
    method mergeWith (line 249) | mergeWith(elts: Iterable<[K & WithEquality,V]>, merge:(v1: V, v2: V) =...
    method map (line 265) | map<K2,V2>(fn:(k:K&WithEquality, v:V)=>[K2&WithEquality,V2]): HashMap<...
    method mapValues (line 279) | mapValues<V2>(fn:(v:V)=>V2): HashMap<K,V2> {
    method forEach (line 288) | forEach(fun:(x:[K,V])=>void): HashMap<K,V> {
    method flatMap (line 303) | flatMap<K2,V2>(fn:(k:K, v:V)=>Iterable<[K2&WithEquality,V2]>): HashMap...
    method allMatch (line 312) | allMatch(predicate:(k:K,v:V)=>boolean): boolean {
    method anyMatch (line 328) | anyMatch(predicate:(k:K,v:V)=>boolean): boolean {
    method contains (line 344) | contains(val: [K&WithEquality,V&WithEquality]): boolean {
    method containsKey (line 358) | containsKey(key: K&WithEquality): boolean {
    method filter (line 367) | filter(predicate:(k:K,v:V)=>boolean): HashMap<K,V> {
    method findAny (line 396) | findAny(predicate:(k:K,v:V)=>boolean): Option<[K,V]> {
    method filterKeys (line 418) | filterKeys(predicate:(k:K)=>boolean): HashMap<K,V> {
    method filterValues (line 432) | filterValues(predicate:(k:V)=>boolean): HashMap<K,V> {
    method fold (line 447) | fold(zero:[K,V], fn:(v1:[K,V],v2:[K,V])=>[K,V]): [K,V] {
    method foldLeft (line 467) | foldLeft<U>(zero: U, fn:(soFar:U,cur:[K,V])=>U): U {
    method foldRight (line 489) | foldRight<U>(zero: U, fn:(cur:[K,V], soFar:U)=>U): U {
    method reduce (line 499) | reduce(combine: (v1:[K,V],v2:[K,V])=>[K,V]): Option<[K,V]> {
    method toArray (line 507) | toArray(): Array<[K,V]> {
    method toVector (line 517) | toVector(): Vector<[K,V]> {
    method toLinkedList (line 527) | toLinkedList(): LinkedList<[K,V]> {
    method toObjectDictionary (line 540) | toObjectDictionary(keyConvert:(k:K)=>string): {[index:string]:V} {
    method toJsMap (line 563) | toJsMap<K2 extends number|string|boolean>(keyConvert:(k:K)=>K2): Map<K...
    method transform (line 573) | transform<U>(converter:(x:HashMap<K,V>)=>U): U {
    method equals (line 582) | equals(other: IMap<K&WithEquality,V&WithEquality>): boolean {
    method hashCode (line 618) | hashCode(): number {
    method toString (line 644) | toString(): string {
    method [inspect] (line 654) | [inspect](): string {
  method [Symbol.iterator] (line 136) | [Symbol.iterator](): Iterator<[K,V]> {
  class EmptyHashMap (line 663) | class EmptyHashMap<K,V> extends HashMap<K,V> {
    method constructor (line 665) | constructor() {
    method get (line 669) | get(k: K & WithEquality): Option<V> {
    method put (line 677) | put(k: K & WithEquality, v: V): HashMap<K,V> {
    method remove (line 688) | remove(k: K&WithEquality): HashMap<K,V> {
    method hasTrueEquality (line 692) | hasTrueEquality(): boolean {
    method putWithMerge (line 696) | putWithMerge(k: K & WithEquality, v: V, merge: (v1: V, v2: V) => V): H...
    method length (line 700) | length(): number {
    method single (line 708) | single(): Option<[K,V]> {
    method isEmpty (line 712) | isEmpty(): boolean {
    method keySet (line 716) | keySet(): HashSet<K> {
    method valueIterable (line 720) | valueIterable(): Iterable<V> {
    method mergeWith (line 735) | mergeWith(other: Iterable<[K & WithEquality,V]>, merge:(v1: V, v2: V) ...
    method map (line 739) | map<K2,V2>(fn:(k:K&WithEquality, v:V)=>[K2&WithEquality,V2]): HashMap<...
    method mapValues (line 743) | mapValues<V2>(fn:(v:V)=>V2): HashMap<K,V2> {
    method forEach (line 747) | forEach(fun:(x:[K,V])=>void): HashMap<K,V> {
    method allMatch (line 751) | allMatch(predicate:(k:K,v:V)=>boolean): boolean {
    method anyMatch (line 755) | anyMatch(predicate:(k:K,v:V)=>boolean): boolean {
    method contains (line 759) | contains(val: [K&WithEquality,V&WithEquality]): boolean {
    method containsKey (line 763) | containsKey(key: K&WithEquality) : boolean {
    method filter (line 767) | filter(predicate:(k:K,v:V)=>boolean): HashMap<K,V> {
    method findAny (line 771) | findAny(predicate:(k:K,v:V)=>boolean): Option<[K,V]> {
    method foldLeft (line 775) | foldLeft<U>(zero: U, fn:(soFar:U,cur:[K,V])=>U): U {
    method toArray (line 779) | toArray(): Array<[K,V]> {
    method toVector (line 783) | toVector(): Vector<[K,V]> {
    method toLinkedList (line 787) | toLinkedList(): LinkedList<[K,V]> {
    method equals (line 791) | equals(other: IMap<K&WithEquality,V&WithEquality>): boolean {
    method hashCode (line 798) | hashCode(): number {
    method toString (line 802) | toString(): string {
  method [Symbol.iterator] (line 673) | [Symbol.iterator](): Iterator<[K,V]> {

FILE: src/HashSet.ts
  class HashSet (line 19) | class HashSet<T> implements ISet<T> {
    method constructor (line 24) | protected constructor(private hamt: any) {}
    method empty (line 30) | static empty<T>(): HashSet<T> {
    method ofIterable (line 39) | static ofIterable<T>(elts: Iterable<T & WithEquality>): HashSet<T> {
    method of (line 47) | static of<T>(...arr: Array<T & WithEquality>): HashSet<T> {
    method isEmpty (line 58) | static isEmpty<T>(v: HashSet<T>): boolean {
    method isNotEmpty (line 69) | static isNotEmpty<T>(v: HashSet<T>): boolean {
    method add (line 83) | add(elt: T & WithEquality): HashSet<T> {
    method addAllArray (line 87) | private addAllArray(elts: Array<T&WithEquality>): HashSet<T> {
    method addAll (line 101) | addAll(elts: Iterable<T & WithEquality>): HashSet<T> {
    method contains (line 124) | contains(elt: T & WithEquality): boolean {
    method map (line 133) | map<U>(mapper:(v:T)=>U&WithEquality): HashSet<U> {
    method mapOption (line 150) | mapOption<U>(mapper:(v:T)=>Option<U&WithEquality>): HashSet<U> {
    method forEach (line 161) | forEach(fun:(x:T)=>void): HashSet<T> {
    method flatMap (line 176) | flatMap<U>(mapper:(v:T)=>HashSet<U&WithEquality>): HashSet<U> {
    method filter (line 188) | filter(predicate:(v:T)=>boolean): HashSet<T> {
    method findAny (line 215) | findAny(predicate:(v:T)=>boolean): Option<T> {
    method fold (line 237) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 256) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method foldRight (line 277) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method toArray (line 300) | toArray(sort?: SortOnSpec<T> | SortBySpec<T>): Array<T & WithEquality> {
    method toVector (line 316) | toVector(): Vector<T & WithEquality> {
    method toLinkedList (line 323) | toLinkedList(): LinkedList<T & WithEquality> {
    method length (line 330) | length(): number {
    method single (line 338) | single(): Option<T> {
    method isEmpty (line 347) | isEmpty(): boolean {
    method diff (line 356) | diff(elts: ISet<T&WithEquality>): HashSet<T> {
    method intersect (line 368) | intersect(other: ISet<T&WithEquality>): HashSet<T> {
    method isSubsetOf (line 374) | isSubsetOf(other: ISet<T&WithEquality>): boolean {
    method remove (line 382) | remove(elt: T&WithEquality): HashSet<T> {
    method removeAll (line 392) | removeAll(elts: Iterable<T&WithEquality>): HashSet<T> {
    method allMatch (line 402) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 418) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method groupBy (line 438) | groupBy<C>(classifier: (v:T)=>C&WithEquality): HashMap<C,HashSet<T>> {
    method arrangeBy (line 466) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method partition (line 482) | partition(predicate:(v:T)=>boolean): [HashSet<T>,HashSet<T>] {
    method reduce (line 508) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 518) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 529) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 539) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 550) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 562) | sumOn(getNumber: (v:T)=>number): number {
    method transform (line 570) | transform<U>(converter:(x:HashSet<T>)=>U): U {
    method toJsSet (line 589) | toJsSet<K extends string|number|boolean>(keyConvert:(k:T)=>K): Set<K> {
    method equals (line 598) | equals(other: HashSet<T>): boolean {
    method hashCode (line 633) | hashCode(): number {
    method toString (line 644) | toString(): string {
    method [inspect] (line 652) | [inspect](): string {
    method mkString (line 665) | mkString(separator: string): string {
  method [Symbol.iterator] (line 76) | [Symbol.iterator](): Iterator<T> {
  class EmptyHashSet (line 676) | class EmptyHashSet<T> extends HashSet<T> {
    method constructor (line 678) | constructor() {
    method add (line 682) | add(elt: T & WithEquality): HashSet<T> {
    method addAll (line 704) | addAll(elts: Iterable<T & WithEquality>): HashSet<T> {
    method contains (line 713) | contains(elt: T & WithEquality): boolean {
    method map (line 717) | map<U>(mapper:(v:T)=>U&WithEquality): HashSet<U> {
    method mapOption (line 721) | mapOption<U>(mapper:(v:T)=>Option<U&WithEquality>): HashSet<U> {
    method forEach (line 725) | forEach(fun:(x:T)=>void): HashSet<T> {
    method filter (line 731) | filter(predicate:(v:T)=>boolean): HashSet<T> {
    method findAny (line 735) | findAny(predicate:(v:T)=>boolean): Option<T> {
    method foldLeft (line 739) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method toArray (line 743) | toArray(sort?: SortOnSpec<T> | SortBySpec<T>): Array<T & WithEquality> {
    method toVector (line 747) | toVector(): Vector<T & WithEquality> {
    method toLinkedList (line 751) | toLinkedList(): LinkedList<T & WithEquality> {
    method length (line 759) | length(): number {
    method isEmpty (line 763) | isEmpty(): boolean {
    method diff (line 767) | diff(elts: ISet<T&WithEquality>): HashSet<T> {
    method intersect (line 771) | intersect(other: ISet<T&WithEquality>): HashSet<T> {
    method anyMatch (line 775) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method groupBy (line 779) | groupBy<C>(classifier: (v:T)=>C&WithEquality): HashMap<C,HashSet<T>> {
    method allMatch (line 785) | allMatch(predicate:(v:T)=>boolean): boolean {
    method partition (line 791) | partition<U extends T>(predicate:(v:T)=>boolean): [HashSet<U>,HashSet<...
    method remove (line 795) | remove(elt: T&WithEquality): HashSet<T> {
    method equals (line 799) | equals(other: HashSet<T>): boolean {
    method hashCode (line 806) | hashCode(): number {
    method toString (line 810) | toString(): string {
    method mkString (line 814) | mkString(separator: string): string {
  method [Symbol.iterator] (line 755) | [Symbol.iterator](): Iterator<T> {

FILE: src/IMap.ts
  type IMap (line 14) | interface IMap<K,V> extends Value, Iterable<[K,V]>, Foldable<[K,V]> {

FILE: src/ISet.ts
  type SortOnSpec (line 18) | type SortOnSpec<T> = {sortOn: ToOrderable<T>|Array<ToOrderable<T>|{desc:...
  type SortBySpec (line 26) | type SortBySpec<T> = {sortBy: (v1:T,v2:T)=>Ordering};
  function isSortOnSpec (line 31) | function isSortOnSpec<T>(sortSpec: SortOnSpec<T> | SortBySpec<T>): sortS...
  type ISet (line 39) | interface ISet<T> extends Collection<T> {

FILE: src/Lazy.ts
  class Lazy (line 11) | class Lazy<T> {
    method constructor (line 16) | private constructor(thunk: ()=>T) {
    method of (line 24) | static of<T>(thunk: ()=>T) {
    method get (line 32) | get(): T {
    method isEvaluated (line 44) | isEvaluated(): boolean {
    method map (line 52) | map<U>(mapper:(v:T)=>U): Lazy<U> {
    method toString (line 59) | toString(): string {
    method [inspect] (line 69) | [inspect](): string {

FILE: src/LinkedList.ts
  class LinkedListStatic (line 38) | class LinkedListStatic {
    method empty (line 42) | empty<T>(): LinkedList<T> {
    method of (line 51) | of<T>(...elts:T[]): LinkedList<T> {
    method ofIterable (line 60) | ofIterable<T>(elts: Iterable<T>): LinkedList<T> {
    method isEmpty (line 79) | isEmpty<T>(l: LinkedList<T>): l is EmptyLinkedList<T> {
    method isNotEmpty (line 92) | isNotEmpty<T>(l: LinkedList<T>): l is ConsLinkedList<T> {
    method unfoldRight (line 110) | unfoldRight<T,U>(seed: T, fn: (x:T)=>Option<[U,T]>): LinkedList<U> {
    method zip (line 138) | zip<A extends any[]>(...iterables: IterableArray<A>): LinkedList<A> {
  type LinkedList (line 161) | type LinkedList<T> = EmptyLinkedList<T> | ConsLinkedList<T>;
  class EmptyLinkedList (line 170) | class EmptyLinkedList<T> implements Seq<T> {
    method hasTrueEquality (line 175) | hasTrueEquality(): boolean {
    method asLinkedList (line 202) | asLinkedList(): LinkedList<T> {
    method length (line 209) | length(): number {
    method single (line 217) | single(): Option<T> {
    method isEmpty (line 224) | isEmpty(): this is EmptyLinkedList<T> {
    method head (line 232) | head(): None<T> {
    method tail (line 240) | tail(): Option<LinkedList<T>> {
    method last (line 249) | last(): Option<T> {
    method get (line 262) | get(idx: number): Option<T> {
    method find (line 271) | find(predicate:(v:T)=>boolean): Option<T> {
    method contains (line 279) | contains(v:T&WithEquality): boolean {
    method take (line 287) | take(n: number): LinkedList<T> {
    method takeWhile (line 295) | takeWhile(predicate: (x:T)=>boolean): LinkedList<T> {
    method takeRightWhile (line 307) | takeRightWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method drop (line 317) | drop(n:number): LinkedList<T> {
    method dropWhile (line 326) | dropWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method dropRight (line 336) | dropRight(n:number): LinkedList<T> {
    method dropRightWhile (line 345) | dropRightWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method fold (line 359) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 377) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method foldRight (line 395) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method zip (line 413) | zip<U>(other: Iterable<U>): LinkedList<[T,U]> {
    method zipWithIndex (line 425) | zipWithIndex(): LinkedList<[T,number]> {
    method reverse (line 435) | reverse(): LinkedList<T> {
    method span (line 448) | span(predicate:(x:T)=>boolean): [LinkedList<T>,LinkedList<T>] {
    method splitAt (line 458) | splitAt(index:number): [LinkedList<T>,LinkedList<T>] {
    method partition (line 474) | partition<U extends T>(predicate:(v:T)=>boolean): [LinkedList<U>,Linke...
    method groupBy (line 486) | groupBy<C>(classifier: (v:T)=>C & WithEquality): HashMap<C,LinkedList<...
    method arrangeBy (line 496) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method shuffle (line 503) | shuffle(): LinkedList<T> {
    method append (line 512) | append(v:T): LinkedList<T> {
    method appendAll (line 519) | appendAll(elts:Iterable<T>): LinkedList<T> {
    method removeAll (line 529) | removeAll(elts:Iterable<T&WithEquality>): LinkedList<T> {
    method removeFirst (line 537) | removeFirst(predicate: (x:T)=>boolean): LinkedList<T> {
    method prepend (line 544) | prepend(elt: T): LinkedList<T> {
    method prependAll (line 551) | prependAll(elt: Iterable<T>): LinkedList<T> {
    method map (line 559) | map<U>(mapper:(v:T)=>U): LinkedList<U> {
    method mapOption (line 573) | mapOption<U>(mapper:(v:T)=>Option<U>): LinkedList<U> {
    method flatMap (line 583) | flatMap<U>(mapper:(v:T)=>LinkedList<U>): LinkedList<U> {
    method allMatch (line 593) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 601) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method filter (line 612) | filter(predicate:(v:T)=>boolean): LinkedList<T> {
    method sortBy (line 627) | sortBy(compare: (v1:T,v2:T)=>Ordering): LinkedList<T> {
    method sortOn (line 647) | sortOn(...getKeys: Array<ToOrderable<T>|{desc:ToOrderable<T>}>): Linke...
    method distinctBy (line 658) | distinctBy<U>(keyExtractor: (x:T)=>U&WithEquality): LinkedList<T> {
    method forEach (line 665) | forEach(fn: (v:T)=>void): LinkedList<T> {
    method reduce (line 675) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 685) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 699) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 709) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 723) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 735) | sumOn(getNumber: (v:T)=>number): number {
    method sliding (line 746) | sliding(count:number): Stream<ConsLinkedList<T>> {
    method scanLeft (line 759) | scanLeft<U>(init:U, fn:(soFar:U,cur:T)=>U): LinkedList<U> {
    method scanRight (line 772) | scanRight<U>(init:U, fn:(cur:T,soFar:U)=>U): LinkedList<U> {
    method mkString (line 783) | mkString(separator: string): string {
    method toArray (line 791) | toArray(): T[] {
    method toVector (line 799) | toVector(): Vector<T> {
    method toMap (line 813) | toMap<K,V>(converter:(x:T)=>[K & WithEquality,V]): HashMap<K,V> {
    method toSet (line 825) | toSet<K>(converter:(x:T)=>K&WithEquality): HashSet<K> {
    method transform (line 833) | transform<U>(converter:(x:LinkedList<T>)=>U): U {
    method equals (line 842) | equals(other: LinkedList<T&WithEquality>): boolean {
    method hashCode (line 854) | hashCode(): number {
    method [inspect] (line 858) | [inspect](): string {
    method toString (line 867) | toString(): string {
  method [Symbol.iterator] (line 182) | [Symbol.iterator](): Iterator<T> {
  class ConsLinkedList (line 880) | class ConsLinkedList<T> implements Seq<T> {
    method constructor (line 890) | public constructor(protected value: T, protected _tail: LinkedList<T>) {}
    method hasTrueEquality (line 895) | hasTrueEquality(): boolean {
    method asLinkedList (line 903) | asLinkedList(): LinkedList<T> {
    method length (line 927) | length(): number {
    method single (line 935) | single(): Option<T> {
    method isEmpty (line 944) | isEmpty(): this is EmptyLinkedList<T> {
    method head (line 952) | head(): Some<T> {
    method tail (line 960) | tail(): Some<LinkedList<T>> {
    method last (line 969) | last(): Some<T> {
    method get (line 989) | get(idx: number): Option<T> {
    method find (line 1008) | find(predicate:(v:T)=>boolean): Option<T> {
    method contains (line 1024) | contains(v:T&WithEquality): boolean {
    method take (line 1032) | take(n: number): LinkedList<T> {
    method takeWhile (line 1047) | takeWhile(predicate: (x:T)=>boolean): LinkedList<T> {
    method takeRightWhile (line 1065) | takeRightWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method drop (line 1075) | drop(n:number): LinkedList<T> {
    method dropWhile (line 1089) | dropWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method dropRight (line 1103) | dropRight(n:number): LinkedList<T> {
    method dropRightWhile (line 1114) | dropRightWhile(predicate:(x:T)=>boolean): LinkedList<T> {
    method fold (line 1128) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 1146) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method foldRight (line 1170) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method zip (line 1188) | zip<U>(other: Iterable<U>): LinkedList<[T,U]> {
    method zipWithIndex (line 1212) | zipWithIndex(): LinkedList<[T,number]> {
    method reverse (line 1222) | reverse(): LinkedList<T> {
    method span (line 1235) | span(predicate:(x:T)=>boolean): [LinkedList<T>,LinkedList<T>] {
    method splitAt (line 1251) | splitAt(index:number): [LinkedList<T>,LinkedList<T>] {
    method partition (line 1274) | partition(predicate:(v:T)=>boolean): [LinkedList<T>,LinkedList<T>] {
    method groupBy (line 1297) | groupBy<C>(classifier: (v:T)=>C & WithEquality): HashMap<C,LinkedList<...
    method arrangeBy (line 1314) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method shuffle (line 1321) | shuffle(): LinkedList<T> {
    method append (line 1330) | append(v:T): LinkedList<T> {
    method appendAll (line 1339) | appendAll(elts:Iterable<T>): LinkedList<T> {
    method removeAll (line 1349) | removeAll(elts:Iterable<T&WithEquality>): LinkedList<T> {
    method removeFirst (line 1357) | removeFirst(predicate: (x:T)=>boolean): LinkedList<T> {
    method prepend (line 1375) | prepend(elt: T): LinkedList<T> {
    method prependAll (line 1382) | prependAll(elts: Iterable<T>): LinkedList<T> {
    method map (line 1396) | map<U>(mapper:(v:T)=>U): LinkedList<U> {
    method mapOption (line 1416) | mapOption<U>(mapper:(v:T)=>Option<U>): LinkedList<U> {
    method flatMap (line 1435) | flatMap<U>(mapper:(v:T)=>LinkedList<U>): LinkedList<U> {
    method allMatch (line 1451) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 1459) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method filter (line 1470) | filter(predicate:(v:T)=>boolean): LinkedList<T> {
    method sortBy (line 1493) | sortBy(compare: (v1:T,v2:T)=>Ordering): LinkedList<T> {
    method sortOn (line 1513) | sortOn(...getKeys: Array<ToOrderable<T>|{desc:ToOrderable<T>}>): Linke...
    method distinctBy (line 1524) | distinctBy<U>(keyExtractor: (x:T)=>U&WithEquality): LinkedList<T> {
    method forEach (line 1531) | forEach(fn: (v:T)=>void): LinkedList<T> {
    method reduce (line 1546) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 1556) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 1570) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 1583) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 1594) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 1606) | sumOn(getNumber: (v:T)=>number): number {
    method sliding (line 1617) | sliding(count:number): Stream<ConsLinkedList<T>> {
    method scanLeft (line 1629) | scanLeft<U>(init:U, fn:(soFar:U,cur:T)=>U): LinkedList<U> {
    method scanRight (line 1650) | scanRight<U>(init:U, fn:(cur:T,soFar:U)=>U): LinkedList<U> {
    method mkString (line 1669) | mkString(separator: string): string {
    method toArray (line 1688) | toArray(): T[] {
    method toVector (line 1702) | toVector(): Vector<T> {
    method toMap (line 1716) | toMap<K,V>(converter:(x:T)=>[K & WithEquality,V]): HashMap<K,V> {
    method toSet (line 1731) | toSet<K>(converter:(x:T)=>K&WithEquality): HashSet<K> {
    method transform (line 1741) | transform<U>(converter:(x:LinkedList<T>)=>U): U {
    method equals (line 1750) | equals(other: LinkedList<T&WithEquality>): boolean {
    method hashCode (line 1792) | hashCode(): number {
    method [inspect] (line 1802) | [inspect](): string {
    method toString (line 1811) | toString(): string {
  method [Symbol.iterator] (line 910) | [Symbol.iterator](): Iterator<T> {

FILE: src/Option.ts
  type Option (line 43) | type Option<T> = Some<T> | None<T>;
  class OptionStatic (line 48) | class OptionStatic {
    method of (line 67) | of<T>(v: T|undefined): Option<T> {
    method ofNullable (line 88) | ofNullable<T>(v:T|undefined|null): Option<T> {
    method some (line 108) | some<T>(v: T): Some<T> {
    method none (line 124) | none<T>(): Option<T> {
    method isSome (line 137) | isSome<T>(o: Option<T>): o is Some<T> {
    method isNone (line 149) | isNone<T>(o: Option<T>): o is None<T> {
    method sequence (line 167) | sequence<T>(elts:Iterable<Option<T>>): Option<Vector<T>> {
    method traverse (line 190) | traverse<T,U>(elts:Iterable<T>, fn: (x:T)=>Option<U>): Option<Vector<U...
    method liftA2 (line 224) | liftA2<T,U,V>(fn:(v1:T,v2:U)=>V): (p1:Option<T>, p2:Option<U>) => Opti...
    method liftAp (line 248) | liftAp<A,B>(fn:(x:A)=>B): (x: {[K in keyof A]: Option<A[K]>;}) => Opti...
    method lift (line 282) | lift<T extends any[],U>(fn: (...args: T)=>U|undefined): (...args:T)=>O...
    method liftNullable (line 313) | liftNullable<T extends any[],U>(fn: (...args: T)=>U|null|undefined): (...
    method try_ (line 343) | try_<T>(fn:()=>T|undefined): Option<T> {
    method tryNullable (line 367) | tryNullable<T>(fn:()=>T|null|undefined): Option<T> {
  function optionHasTrueEquality (line 377) | function optionHasTrueEquality<T>(opt: Option<T>): boolean {
  class Some (line 393) | class Some<T> implements Value {
    method constructor (line 397) | constructor(private value: T) {}
    method isSome (line 407) | isSome(): this is Some<T> {
    method isNone (line 414) | isNone(): this is None<T> {
    method asOption (line 422) | asOption(): Option<T> {
    method get (line 431) | get(): T {
    method orElse (line 439) | orElse(other: Option<T>): Option<T> {
    method getOrThrow (line 449) | getOrThrow(errorInfo?: Error|string): T {
    method contains (line 457) | contains(v: T&WithEquality): boolean {
    method getOrUndefined (line 471) | getOrUndefined(): T | undefined {
    method getOrNull (line 485) | getOrNull(): T | null {
    method getOrElse (line 493) | getOrElse(alt: T): T {
    method getOrCall (line 507) | getOrCall(fn: ()=>T): T {
    method map (line 523) | map<U>(fn: (v:T)=>U): Option<U> {
    method mapNullable (line 541) | mapNullable<U>(fn: (v:T)=>U|null|undefined): Option<U> {
    method flatMap (line 551) | flatMap<U>(mapper:(v:T)=>Option<U>): Option<U> {
    method filter (line 562) | filter(fn: (v:T)=>boolean): Option<T> {
    method ifSome (line 570) | ifSome(fn:(v:T)=>void): Option<T> {
    method ifNone (line 579) | ifNone(fn:()=>void): Option<T> {
    method match (line 594) | match<U>(cases: {Some: (v:T)=>U, None: ()=>U}): U {
    method transform (line 602) | transform<U>(converter:(x:Option<T>)=>U): U {
    method toVector (line 611) | toVector(): Vector<T> {
    method toEither (line 619) | toEither<L>(left: L): Either<L,T> {
    method orCall (line 627) | orCall(_: () => Option<T>): Option<T> {
    method hasTrueEquality (line 631) | hasTrueEquality<T>(): boolean {
    method equals (line 640) | equals(other: Option<T&WithEquality>): boolean {
    method hashCode (line 660) | hashCode(): number {
    method toString (line 667) | toString(): string {
    method [inspect] (line 674) | [inspect](): string {
  class None (line 687) | class None<T> implements Value {
    method isSome (line 697) | isSome(): this is Some<T> {
    method isNone (line 704) | isNone(): this is None<T> {
    method asOption (line 712) | asOption(): Option<T> {
    method orElse (line 720) | orElse(other: Option<T>): Option<T> {
    method getOrThrow (line 730) | getOrThrow(errorInfo?: Error|string): T & WithEquality {
    method contains (line 741) | contains(v: T&WithEquality): boolean {
    method getOrUndefined (line 755) | getOrUndefined(): T|undefined {
    method getOrNull (line 769) | getOrNull(): T|null {
    method getOrElse (line 777) | getOrElse(alt: T): T {
    method getOrCall (line 791) | getOrCall(fn: ()=>T): T {
    method map (line 807) | map<U>(fn: (v:T)=>U): Option<U> {
    method mapNullable (line 825) | mapNullable<U>(fn: (v:T)=>U|null|undefined): Option<U> {
    method flatMap (line 835) | flatMap<U>(mapper:(v:T)=>Option<U>): Option<U> {
    method filter (line 846) | filter(fn: (v:T)=>boolean): Option<T> {
    method ifSome (line 854) | ifSome(fn:(v:T)=>void): Option<T> {
    method ifNone (line 862) | ifNone(fn:()=>void): Option<T> {
    method match (line 878) | match<U>(cases: {Some: (v:T)=>U, None: ()=>U}): U {
    method transform (line 886) | transform<U>(converter:(x:Option<T>)=>U): U {
    method toVector (line 895) | toVector(): Vector<T> {
    method toEither (line 903) | toEither<L>(left: L): Either<L,T> {
    method orCall (line 911) | orCall(fn: () => Option<T>): Option<T> {
    method hasTrueEquality (line 915) | hasTrueEquality<T>(): boolean {
    method equals (line 924) | equals(other: Option<T&WithEquality>): boolean {
    method hashCode (line 933) | hashCode(): number {
    method toString (line 940) | toString(): string {
    method [inspect] (line 947) | [inspect](): string {

FILE: src/Predicate.ts
  type Predicate (line 37) | interface Predicate<T> {
  class PredicateStatic (line 74) | class PredicateStatic {
    method of (line 80) | of<T>(fn: (x:T)=>boolean): Predicate<T> {
    method equals (line 92) | equals<T>(other: T&WithEquality): Predicate<T&WithEquality> {
    method isIn (line 100) | isIn<T>(others: Iterable<T&WithEquality>): Predicate<T&WithEquality> {
    method allOf (line 107) | allOf<T>(...predicates: Array<(x:T)=>boolean>): Predicate<T> {
    method anyOf (line 114) | anyOf<T>(...predicates: Array<(x:T)=>boolean>): Predicate<T> {
    method noneOf (line 121) | noneOf<T>(...predicates: Array<(x:T)=>boolean>): Predicate<T> {

FILE: src/Seq.ts
  type IterableArray (line 15) | type IterableArray<T> = { [K in keyof T] : Iterable<T[K]> };
  type Seq (line 21) | interface Seq<T> extends Collection<T> {

FILE: src/SeqHelpers.ts
  function shuffle (line 14) | function shuffle(array: any[]) {
  function arrangeBy (line 37) | function arrangeBy<T,K>(collection: Collection<T>, getKey: (v:T)=>K&With...
  function seqHasTrueEquality (line 46) | function seqHasTrueEquality<T>(seq: Seq<T>): boolean {
  function zipWithIndex (line 53) | function zipWithIndex<T>(seq: Seq<T>): Seq<[T,number]> {
  function sortOn (line 60) | function sortOn<T>(seq: Seq<T>, getKeys: Array<ToOrderable<T>|{desc:ToOr...
  function distinctBy (line 86) | function distinctBy<T,U>(seq: Collection<T>, keyExtractor: (x:T)=>U&With...
  function toStringHelper (line 103) | function toStringHelper(
  function minBy (line 140) | function minBy<T>(coll: Collection<T>, compare: (v1:T,v2:T)=>Ordering): ...
  function minOn (line 147) | function minOn<T>(coll: Collection<T>, getSortable: ToOrderable<T>): Opt...
  function maxBy (line 168) | function maxBy<T>(coll: Collection<T>, compare: (v1:T,v2:T)=>Ordering): ...
  function maxOn (line 175) | function maxOn<T>(coll: Collection<T>, getSortable: ToOrderable<T>): Opt...
  function sumOn (line 196) | function sumOn<T>(coll: Collection<T>, getNumber: (v:T)=>number): number {
  function reduce (line 203) | function reduce<T>(coll: Collection<T>, combine: (v1:T,v2:T)=>T): Option...
  function sliding (line 219) | function sliding<T>(seq: Seq<T>, count:number): Stream<Seq<T>> {
  function removeAll (line 232) | function removeAll<T>(seq: Seq<T>, elts:Iterable<T&WithEquality>): Seq<T> {

FILE: src/Stream.ts
  type Stream (line 39) | type Stream<T> = EmptyStream<T> | ConsStream<T>;
  class StreamStatic (line 44) | class StreamStatic {
    method empty (line 48) | empty<T>(): Stream<T> {
    method of (line 57) | of<T>(...elts:T[]): Stream<T> {
    method ofIterable (line 66) | ofIterable<T>(elts: Iterable<T>): Stream<T> {
    method isEmpty (line 87) | isEmpty<T>(s: Stream<T>): s is EmptyStream<T> {
    method isNotEmpty (line 100) | isNotEmpty<T>(s: Stream<T>): s is ConsStream<T> {
    method ofArray (line 107) | private ofArray<T>(elts: Array<T>): Stream<T> {
    method iterate (line 121) | iterate<T>(seed:T, fn: (v:T)=>T): ConsStream<T> {
    method continually (line 134) | continually<T>(fn: ()=>T): ConsStream<T> {
    method unfoldRight (line 152) | unfoldRight<T,U>(seed: T, fn: (x:T)=>Option<[U,T]>): Stream<U> {
    method zip (line 178) | zip<A extends any[]>(...iterables: IterableArray<A>): Stream<A> {
  class EmptyStream (line 205) | class EmptyStream<T> implements Seq<T> {
    method asStream (line 230) | asStream(): Stream<T> {
    method hasTrueEquality (line 237) | hasTrueEquality(): boolean {
    method length (line 244) | length(): number {
    method single (line 252) | single(): Option<T> {
    method isEmpty (line 259) | isEmpty(): this is EmptyStream<T> {
    method head (line 268) | head(): Option<T> {
    method tail (line 276) | tail(): Option<Stream<T>> {
    method last (line 285) | last(): Option<T> {
    method get (line 298) | get(idx: number): Option<T> {
    method find (line 307) | find(predicate:(v:T)=>boolean): Option<T> {
    method contains (line 315) | contains(v:T&WithEquality): boolean {
    method take (line 323) | take(n: number): Stream<T> {
    method takeWhile (line 331) | takeWhile(predicate: (x:T)=>boolean): Stream<T> {
    method takeRightWhile (line 343) | takeRightWhile(predicate:(x:T)=>boolean): Stream<T> {
    method drop (line 353) | drop(n:number): Stream<T> {
    method dropWhile (line 362) | dropWhile(predicate:(x:T)=>boolean): Stream<T> {
    method dropRight (line 372) | dropRight(n:number): Stream<T> {
    method dropRightWhile (line 381) | dropRightWhile(predicate:(x:T)=>boolean): Stream<T> {
    method fold (line 395) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 413) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method foldRight (line 431) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method zip (line 449) | zip<U>(other: Iterable<U>): Stream<[T,U]> {
    method zipWithIndex (line 461) | zipWithIndex(): Stream<[T,number]> {
    method reverse (line 471) | reverse(): Stream<T> {
    method span (line 484) | span(predicate:(x:T)=>boolean): [Stream<T>,Stream<T>] {
    method splitAt (line 494) | splitAt(index:number): [Stream<T>,Stream<T>] {
    method partition (line 510) | partition<U extends T>(predicate:(v:T)=>boolean): [Stream<U>,Stream<an...
    method groupBy (line 522) | groupBy<C>(classifier: (v:T)=>C & WithEquality): HashMap<C,Stream<T>> {
    method arrangeBy (line 532) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method shuffle (line 539) | shuffle(): Stream<T> {
    method append (line 546) | append(v:T): Stream<T> {
    method appendAll (line 553) | appendAll(elts:Iterable<T>): Stream<T> {
    method removeAll (line 563) | removeAll(elts:Iterable<T&WithEquality>): Stream<T> {
    method removeFirst (line 571) | removeFirst(predicate: (x:T)=>boolean): Stream<T> {
    method appendStream (line 584) | appendStream(elts:Stream<T>): Stream<T> {
    method prepend (line 591) | prepend(elt: T): Stream<T> {
    method prependAll (line 598) | prependAll(elt: Iterable<T>): Stream<T> {
    method cycle (line 609) | cycle(): Stream<T> {
    method map (line 617) | map<U>(mapper:(v:T)=>U): Stream<U> {
    method mapOption (line 631) | mapOption<U>(mapper:(v:T)=>Option<U>): Stream<U> {
    method flatMap (line 641) | flatMap<U>(mapper:(v:T)=>Stream<U>): Stream<U> {
    method allMatch (line 651) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 659) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method filter (line 670) | filter(predicate:(v:T)=>boolean): Stream<T> {
    method sortBy (line 685) | sortBy(compare: (v1:T,v2:T)=>Ordering): Stream<T> {
    method sortOn (line 705) | sortOn(...getKeys: Array<ToOrderable<T>|{desc:ToOrderable<T>}>): Strea...
    method distinctBy (line 716) | distinctBy<U>(keyExtractor: (x:T)=>U&WithEquality): Stream<T> {
    method forEach (line 723) | forEach(fn: (v:T)=>void): Stream<T> {
    method reduce (line 733) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 743) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 757) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 767) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 781) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 793) | sumOn(getNumber: (v:T)=>number): number {
    method sliding (line 804) | sliding(count:number): Stream<Stream<T>> {
    method scanLeft (line 816) | scanLeft<U>(init:U, fn:(soFar:U,cur:T)=>U): Stream<U> {
    method scanRight (line 829) | scanRight<U>(init:U, fn:(cur:T,soFar:U)=>U): Stream<U> {
    method mkString (line 840) | mkString(separator: string): string {
    method toArray (line 848) | toArray(): T[] {
    method toVector (line 856) | toVector(): Vector<T> {
    method toMap (line 870) | toMap<K,V>(converter:(x:T)=>[K & WithEquality,V]): HashMap<K,V> {
    method toSet (line 882) | toSet<K>(converter:(x:T)=>K&WithEquality): HashSet<K> {
    method toLinkedList (line 889) | toLinkedList(): LinkedList<T> {
    method transform (line 897) | transform<U>(converter:(x:Stream<T>)=>U): U {
    method equals (line 906) | equals(other: Stream<T&WithEquality>): boolean {
    method hashCode (line 918) | hashCode(): number {
    method [inspect] (line 922) | [inspect](): string {
    method toString (line 931) | toString(): string {
  method [Symbol.iterator] (line 215) | [Symbol.iterator](): Iterator<T> {
  class ConsStream (line 944) | class ConsStream<T> implements Seq<T> {
    method constructor (line 954) | public constructor(protected value: T, protected _tail: Lazy<Stream<T>...
    method asStream (line 977) | asStream(): Stream<T> {
    method hasTrueEquality (line 984) | hasTrueEquality(): boolean {
    method length (line 991) | length(): number {
    method single (line 999) | single(): Option<T> {
    method isEmpty (line 1008) | isEmpty(): this is EmptyStream<T> {
    method head (line 1017) | head(): Some<T> {
    method tail (line 1025) | tail(): Some<Stream<T>> {
    method last (line 1034) | last(): Some<T> {
    method get (line 1054) | get(idx: number): Option<T> {
    method find (line 1073) | find(predicate:(v:T)=>boolean): Option<T> {
    method contains (line 1089) | contains(v:T&WithEquality): boolean {
    method take (line 1097) | take(n: number): Stream<T> {
    method takeWhile (line 1109) | takeWhile(predicate: (x:T)=>boolean): Stream<T> {
    method takeRightWhile (line 1125) | takeRightWhile(predicate:(x:T)=>boolean): Stream<T> {
    method drop (line 1135) | drop(n:number): Stream<T> {
    method dropWhile (line 1149) | dropWhile(predicate:(x:T)=>boolean): Stream<T> {
    method dropRight (line 1163) | dropRight(n:number): Stream<T> {
    method dropRightWhile (line 1174) | dropRightWhile(predicate:(x:T)=>boolean): Stream<T> {
    method fold (line 1188) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 1206) | foldLeft<U>(zero: U, fn:(soFar:U,cur:T)=>U): U {
    method foldRight (line 1230) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method zip (line 1248) | zip<U>(other: Iterable<U>): Stream<[T,U]> {
    method zipWithIndex (line 1269) | zipWithIndex(): Stream<[T,number]> {
    method reverse (line 1279) | reverse(): Stream<T> {
    method span (line 1292) | span(predicate:(x:T)=>boolean): [Stream<T>,Stream<T>] {
    method splitAt (line 1302) | splitAt(index:number): [Stream<T>,Stream<T>] {
    method partition (line 1318) | partition(predicate:(v:T)=>boolean): [Stream<T>,Stream<T>] {
    method groupBy (line 1331) | groupBy<C>(classifier: (v:T)=>C & WithEquality): HashMap<C,Stream<T>> {
    method arrangeBy (line 1346) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method shuffle (line 1353) | shuffle(): Stream<T> {
    method append (line 1360) | append(v:T): Stream<T> {
    method appendAll (line 1370) | appendAll(elts:Iterable<T>): Stream<T> {
    method removeAll (line 1380) | removeAll(elts:Iterable<T&WithEquality>): Stream<T> {
    method removeFirst (line 1388) | removeFirst(predicate: (x:T)=>boolean): Stream<T> {
    method appendStream (line 1405) | appendStream(elts:Stream<T>): Stream<T> {
    method prepend (line 1415) | prepend(elt: T): Stream<T> {
    method prependAll (line 1424) | prependAll(elts: Iterable<T>): Stream<T> {
    method cycle (line 1435) | cycle(): Stream<T> {
    method _cycle (line 1439) | private _cycle(toRepeat: Stream<T>): Stream<T> {
    method map (line 1450) | map<U>(mapper:(v:T)=>U): Stream<U> {
    method mapOption (line 1465) | mapOption<U>(mapper:(v:T)=>Option<U>): Stream<U> {
    method flatMap (line 1479) | flatMap<U>(mapper:(v:T)=>Stream<U>): Stream<U> {
    method allMatch (line 1490) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 1498) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method filter (line 1509) | filter(predicate:(v:T)=>boolean): Stream<T> {
    method sortBy (line 1527) | sortBy(compare: (v1:T,v2:T)=>Ordering): Stream<T> {
    method sortOn (line 1547) | sortOn(...getKeys: Array<ToOrderable<T>|{desc:ToOrderable<T>}>): Strea...
    method distinctBy (line 1558) | distinctBy<U>(keyExtractor: (x:T)=>U&WithEquality): Stream<T> {
    method forEach (line 1565) | forEach(fn: (v:T)=>void): Stream<T> {
    method reduce (line 1580) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 1590) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 1604) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 1614) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 1628) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 1640) | sumOn(getNumber: (v:T)=>number): number {
    method sliding (line 1651) | sliding(count:number): Stream<Stream<T>> {
    method scanLeft (line 1663) | scanLeft<U>(init:U, fn:(soFar:U,cur:T)=>U): Stream<U> {
    method scanRight (line 1678) | scanRight<U>(init:U, fn:(cur:T,soFar:U)=>U): Stream<U> {
    method mkString (line 1691) | mkString(separator: string): string {
    method toArray (line 1710) | toArray(): T[] {
    method toVector (line 1724) | toVector(): Vector<T> {
    method toMap (line 1738) | toMap<K,V>(converter:(x:T)=>[K & WithEquality,V]): HashMap<K,V> {
    method toSet (line 1753) | toSet<K>(converter:(x:T)=>K&WithEquality): HashSet<K> {
    method toLinkedList (line 1762) | toLinkedList(): LinkedList<T> {
    method transform (line 1770) | transform<U>(converter:(x:Stream<T>)=>U): U {
    method equals (line 1779) | equals(other: Stream<T&WithEquality>): boolean {
    method hashCode (line 1821) | hashCode(): number {
    method [inspect] (line 1831) | [inspect](): string {
    method toString (line 1840) | toString(): string {
  method [Symbol.iterator] (line 959) | [Symbol.iterator](): Iterator<T> {

FILE: src/Tuple2.ts
  class Tuple2 (line 16) | class Tuple2<T,U> implements Value {
    method constructor (line 18) | private constructor(private _fst: T,
    method of (line 24) | static of<T,U>(fst: T, snd: U) {
    method ofArray (line 33) | static ofArray<T,U>(pair: Array<T|U>): Option<Tuple2<T,U>> {
    method ofPair (line 44) | static ofPair<T,U>(pair: [T, U]): Tuple2<T,U> {
    method hasTrueEquality (line 51) | hasTrueEquality(): boolean {
    method fst (line 59) | fst(): T {
    method snd (line 66) | snd(): U {
    method map1 (line 73) | map1<V>(fn: (v:T)=>V): Tuple2<V,U> {
    method map2 (line 80) | map2<V>(fn: (v:U)=>V): Tuple2<T,V> {
    method map (line 87) | map<T1,U1>(fn: (a:T,b:U)=> Tuple2<T1,U1>): Tuple2<T1,U1> {
    method transform (line 95) | transform<V>(converter:(x:Tuple2<T,U>)=>V): V {
    method equals (line 104) | equals(other: Tuple2<T&WithEquality,U&WithEquality>): boolean {
    method hashCode (line 121) | hashCode(): number {
    method toPair (line 131) | toPair(): [T,U] {
    method toArray (line 141) | toArray(): Array<T|U> {
    method toVector (line 148) | toVector(): Vector<T|U> {
    method toLinkedList (line 155) | toLinkedList(): ConsLinkedList<T|U> {
    method toString (line 162) | toString(): string {
    method [inspect] (line 170) | [inspect](): string {

FILE: src/Value.ts
  type Value (line 10) | interface Value {

FILE: src/Vector.ts
  class Vector (line 18) | class Vector<T> implements Seq<T> {
    method constructor (line 24) | protected constructor(private _list: L.List<T>) {}
    method empty (line 30) | static empty<T>(): Vector<T> {
    method of (line 38) | static of<T>(...data: T[]): Vector<T> {
    method ofIterable (line 47) | static ofIterable<T>(elts: Iterable<T>): Vector<T> {
    method isEmpty (line 58) | static isEmpty<T>(v: Vector<T>): boolean {
    method isNotEmpty (line 69) | static isNotEmpty<T>(v: Vector<T>): boolean {
    method length (line 76) | length(): number {
    method isEmpty (line 83) | isEmpty(): boolean {
    method unfoldRight (line 101) | static unfoldRight<T,U>(seed: T, fn: (x:T)=>Option<[U,T]>): Vector<U> {
    method get (line 116) | get(index: number): Option<T> {
    method single (line 124) | single(): Option<T> {
    method replace (line 134) | replace(index: number, val: T): Vector<T> {
    method replaceFirst (line 149) | replaceFirst(element: T&WithEquality, newVal: T&WithEquality): Vector<...
    method replaceAll (line 169) | replaceAll(element: T&WithEquality, newVal: T&WithEquality): Vector<T> {
    method append (line 189) | append(val:T): Vector<T> {
    method appendAll (line 197) | appendAll(elts: Iterable<T>): Vector<T> {
    method removeAll (line 211) | removeAll(elts:Iterable<T&WithEquality>): Vector<T> {
    method head (line 220) | head(): Option<T> {
    method last (line 229) | last(): Option<T> {
    method init (line 241) | init(): Vector<T> {
    method dropWhile (line 250) | dropWhile(predicate:(x:T)=>boolean): Vector<T> {
    method find (line 259) | find(predicate:(v:T)=>boolean): Option<T> {
    method findLast (line 268) | findLast(predicate:(v:T)=>boolean): Option<T> {
    method findIndex (line 277) | findIndex(predicate:(v:T)=>boolean): Option<number> {
    method allMatch (line 287) | allMatch(predicate:(v:T)=>boolean): boolean {
    method anyMatch (line 295) | anyMatch(predicate:(v:T)=>boolean): boolean {
    method partition (line 311) | partition(predicate:(v:T)=>boolean): [Vector<T>,Vector<T>] {
    method contains (line 320) | contains(v:T&WithEquality): boolean {
    method groupBy (line 332) | groupBy<C>(classifier: (v:T)=>C & WithEquality): HashMap<C,Vector<T>> {
    method arrangeBy (line 347) | arrangeBy<K>(getKey: (v:T)=>K&WithEquality): Option<HashMap<K,T>> {
    method distinctBy (line 358) | distinctBy<U>(keyExtractor: (x:T)=>U&WithEquality): Vector<T> {
    method forEach (line 369) | forEach(fun:(x:T)=>void):Vector<T> {
    method map (line 378) | map<U>(fun:(x:T)=>U): Vector<U> {
    method filter (line 389) | filter(fun:(v:T)=>boolean): Vector<T> {
    method mapOption (line 403) | mapOption<U>(mapper:(v:T)=>Option<U>): Vector<U> {
    method flatMap (line 420) | flatMap<U>(mapper:(v:T)=>Vector<U>): Vector<U> {
    method fold (line 434) | fold(zero:T, fn:(v1:T,v2:T)=>T): T {
    method foldLeft (line 452) | foldLeft<U>(zero:U, fn:(soFar:U,cur:T)=>U):U {
    method foldRight (line 470) | foldRight<U>(zero: U, fn:(cur:T, soFar:U)=>U): U {
    method indexOf (line 481) | indexOf(element: T & WithEquality): Option<number> {
    method shuffle (line 489) | shuffle(): Vector<T> {
    method transform (line 497) | transform<U>(converter:(x:Vector<T>)=>U): U {
    method equals (line 506) | equals(other:Vector<T&WithEquality>): boolean {
    method hashCode (line 537) | hashCode(): number {
    method toString (line 550) | toString(): string {
    method [inspect] (line 565) | [inspect](): string {
    method mkString (line 576) | mkString(separator: string): string {
    method sortBy (line 593) | sortBy(compare: (v1:T,v2:T)=>Ordering): Vector<T> {
    method sortOn (line 613) | sortOn(...getKeys: Array<ToOrderable<T>|{desc:ToOrderable<T>}>): Vecto...
    method toMap (line 627) | toMap<K,V>(converter:(x:T)=>[K & WithEquality,V]): HashMap<K,V> {
    method toSet (line 642) | toSet<K>(converter:(x:T)=>K&WithEquality): HashSet<K> {
    method toArray (line 651) | toArray(): T[] {
    method hasTrueEquality (line 658) | hasTrueEquality(): boolean {
    method zip (line 678) | static zip<A extends any[]>(...iterables: IterableArray<A>): Vector<A> {
    method zip (line 704) | zip<U>(other: Iterable<U>): Vector<[T,U]> {
    method reverse (line 725) | reverse(): Vector<T> {
    method zipWithIndex (line 737) | zipWithIndex(): Vector<[T,number]> {
    method takeWhile (line 745) | takeWhile(predicate:(x:T)=>boolean): Vector<T> {
    method takeRightWhile (line 757) | takeRightWhile(predicate:(x:T)=>boolean): Vector<T> {
    method splitAt (line 767) | splitAt(index:number): [Vector<T>,Vector<T>] {
    method span (line 783) | span(predicate:(x:T)=>boolean): [Vector<T>,Vector<T>] {
    method drop (line 795) | drop(n:number): Vector<T> {
    method take (line 806) | take(n:number): Vector<T> {
    method prepend (line 816) | prepend(elt: T): Vector<T> {
    method prependAll (line 823) | prependAll(elts: Iterable<T>): Vector<T> {
    method removeFirst (line 831) | removeFirst(predicate: (v:T)=>boolean): Vector<T> {
    method dropRight (line 842) | dropRight(n:number): Vector<T> {
    method dropRightWhile (line 854) | dropRightWhile(predicate:(x:T)=>boolean): Vector<T> {
    method tail (line 868) | tail(): Option<Vector<T>> {
    method reduce (line 881) | reduce(combine: (v1:T,v2:T)=>T): Option<T> {
    method minBy (line 891) | minBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method minOn (line 905) | minOn(getOrderable: ToOrderable<T>): Option<T> {
    method maxBy (line 915) | maxBy(compare: (v1:T,v2:T)=>Ordering): Option<T> {
    method maxOn (line 929) | maxOn(getOrderable: ToOrderable<T>): Option<T> {
    method sumOn (line 941) | sumOn(getNumber: (v:T)=>number): number {
    method sliding (line 952) | sliding(count:number): Stream<Vector<T>> {
    method scanLeft (line 965) | scanLeft<U>(init:U, fn:(soFar:U,cur:T)=>U): Vector<U> {
    method scanRight (line 978) | scanRight<U>(init:U, fn:(cur:T,soFar:U)=>U): Vector<U> {
  method [Symbol.iterator] (line 362) | [Symbol.iterator](): Iterator<T> {

FILE: tests/Collection.ts
  function runTests (line 10) | function runTests(seqName: string,

FILE: tests/Comments.ts
  function getCodeSamples (line 18) | function getCodeSamples(commentText: string): Vector<string> {
  type SampleInfo (line 50) | type SampleInfo = {
  function getCommentsInlineCode (line 56) | function getCommentsInlineCode(scanner: ts.Scanner): Vector<SampleInfo> {
  function getCodeSampleInfo (line 77) | function getCodeSampleInfo(identifier: string, codeSample: string): Samp...
  function storeInVariable (line 92) | function storeInVariable(code: string) {
  function generateTestContents (line 124) | function generateTestContents(fname: string, sampleInfo: SampleInfo) {
  function generateTestFileContents (line 153) | function generateTestFileContents(fname: string, samplesInfo: Vector<Sam...
  function generateTestCommentsFile (line 228) | function generateTestCommentsFile(filepath: string, fname: string): void {
  function generateTestComments (line 245) | function generateTestComments(): void {

FILE: tests/DocLinks.ts
  function checkUrlsInText (line 7) | function checkUrlsInText(text:string, urlFilter: (url:string)=>boolean):...

FILE: tests/Future.ts
  function ensureFailedWithValue (line 8) | async function ensureFailedWithValue<T>(val: any, promise:Promise<T>) {
  type Operation (line 189) | type Operation = {type:string, input: number, time: number};

FILE: tests/HashMap.ts
  type MyEnum (line 13) | type MyEnum = "a" | "b" | "c";
  class TestClass (line 168) | class TestClass implements HasEquals {
    method constructor (line 169) | constructor(
    method equals (line 173) | public equals(other: unknown): boolean {
    method hashCode (line 177) | public hashCode(): number {
  method equals (line 201) | equals(this:any, b:any) { return this.field1===b.field1 && this.field2==...
  method hashCode (line 202) | hashCode(this:any) { return fieldsHashCode(this.field1, this.field2);}

FILE: tests/SampleData.ts
  class MyClass (line 6) | class MyClass {
    method constructor (line 7) | constructor(private field1:string, private field2:number) {}
    method equals (line 8) | equals(other: MyClass): boolean {
    method getField1 (line 15) | getField1(): string {
    method getField2 (line 18) | getField2(): number {
    method hashCode (line 21) | hashCode(): number {
    method toString (line 24) | toString(): string {
  class MySubclass (line 32) | class MySubclass extends MyClass {
    method constructor (line 33) | constructor(field1: string, field2:number, private field3:string) {
    method getField3 (line 37) | getField3(): string {

FILE: tests/Seq.ts
  function runTests (line 20) | function runTests(seqName: string,

FILE: tests/TestHelpers.ts
  constant TMP_FILENAME (line 5) | const TMP_FILENAME = "tmp.ts";
  function diagnosticMsgToString (line 7) | function diagnosticMsgToString(diagMsg: string|ts.DiagnosticMessageChain...
  function diagnosticMsgContains (line 21) | function diagnosticMsgContains(diagMsg: string|ts.DiagnosticMessageChain...
  function assertFailCompile (line 28) | function assertFailCompile(contents: string, expectedMsg: string): void {

FILE: tests/Vector.ts
  function checkTake (line 132) | function checkTake<T>(longer: Vector<T>, n: number, shorter: Vector<T>) {
  function checkAppend (line 160) | function checkAppend<T>(base: Vector<T>, toAppend: Iterable<T>, combined...