SYMBOL INDEX (102 symbols across 56 files)

FILE: dtslint/ts4.8/FlatMap.ts
  type RAW (line 5) | interface RAW<R, E, A> {
  type RAWTypeLambda (line 9) | interface RAWTypeLambda extends TypeLambda {

FILE: dtslint/ts4.8/Product.ts
  type RAW (line 4) | interface RAW<R, E, A> {
  type RAWTypeLambda (line 8) | interface RAWTypeLambda extends TypeLambda {

FILE: dtslint/ts4.8/ReadonlyRecord.ts
  function mapToBoolean (line 37) | function mapToBoolean(): { [K in keyof typeof constStruct]: boolean } {

FILE: dtslint/ts4.8/SemiAlternative.ts
  type RAW (line 5) | interface RAW<R, E, A> {
  type RAWTypeLambda (line 9) | interface RAWTypeLambda extends TypeLambda {

FILE: dtslint/ts4.8/index.ts
  function testIssue536 (line 4) | function testIssue536<F extends _.TypeLambda, G extends _.TypeLambda, R,...

FILE: src/Either.ts
  type Either (line 40) | type Either<E, A> = Left<E> | Right<A>
  type Left (line 46) | interface Left<E> {
  type Right (line 55) | interface Right<A> {
  type EitherTypeLambda (line 64) | interface EitherTypeLambda extends TypeLambda {

FILE: src/Function.ts
  type FunctionTypeLambda (line 10) | interface FunctionTypeLambda extends TypeLambda {
  type LazyArg (line 92) | interface LazyArg<A> {
  type FunctionN (line 104) | interface FunctionN<A extends ReadonlyArray<unknown>, B> {
  function flow (line 312) | function flow(
  function pipe (line 689) | function pipe(

FILE: src/HKT.ts
  type TypeClass (line 13) | interface TypeClass<F extends TypeLambda> {
  type TypeLambda (line 20) | interface TypeLambda {
  type Kind (line 30) | type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {

FILE: src/Identity.ts
  type Identity (line 28) | type Identity<A> = A
  type IdentityTypeLambda (line 34) | interface IdentityTypeLambda extends TypeLambda {
  type IdentityTypeLambdaFix (line 42) | interface IdentityTypeLambdaFix<A> extends TypeLambda {

FILE: src/Option.ts
  type Option (line 44) | type Option<A> = None | Some<A>
  type None (line 50) | interface None {
  type Some (line 58) | interface Some<A> {
  type OptionTypeLambda (line 67) | interface OptionTypeLambda extends TypeLambda {

FILE: src/Ordering.ts
  type Ordering (line 13) | type Ordering = -1 | 0 | 1

FILE: src/Predicate.ts
  type Predicate (line 20) | interface Predicate<A> {
  type PredicateTypeLambda (line 28) | interface PredicateTypeLambda extends TypeLambda {
  type Refinement (line 36) | interface Refinement<A, B extends A> {

FILE: src/ReadonlyArray.ts
  type ReadonlyArrayTypeLambda (line 44) | interface ReadonlyArrayTypeLambda extends TypeLambda {
  type NonEmptyReadonlyArray (line 52) | type NonEmptyReadonlyArray<A> = readonly [A, ...Array<A>]
  type NonEmptyArray (line 58) | type NonEmptyArray<A> = [A, ...Array<A>]
  function every (line 2169) | function every<A>(predicate: Predicate<A>): Predicate<ReadonlyArray<A>> {

FILE: src/ReadonlyRecord.ts
  type ReadonlyRecord (line 28) | interface ReadonlyRecord<A> {
  type ReadonlyRecordTypeLambda (line 36) | interface ReadonlyRecordTypeLambda extends TypeLambda {

FILE: src/These.ts
  type Both (line 42) | interface Both<E, A> {
  type These (line 52) | type These<E, A> = Either<E, A> | Both<E, A>
  type Validated (line 58) | type Validated<E, A> = These<NonEmptyReadonlyArray<E>, A>
  type TheseTypeLambda (line 64) | interface TheseTypeLambda extends TypeLambda {
  type ValidatedTypeLambda (line 72) | interface ValidatedTypeLambda extends TypeLambda {

FILE: src/Tuple.ts
  type TupleTypeLambda (line 18) | interface TupleTypeLambda extends TypeLambda {

FILE: src/typeclass/Alternative.ts
  type Alternative (line 12) | interface Alternative<F extends TypeLambda> extends SemiAlternative<F>, ...

FILE: src/typeclass/Applicative.ts
  type Applicative (line 15) | interface Applicative<F extends TypeLambda> extends SemiApplicative<F>, ...

FILE: src/typeclass/Bicovariant.ts
  type Bicovariant (line 12) | interface Bicovariant<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/Bounded.ts
  type Bounded (line 15) | interface Bounded<A> extends Order<A> {
  type BoundedTypeLambda (line 24) | interface BoundedTypeLambda extends TypeLambda {

FILE: src/typeclass/Chainable.ts
  type Chainable (line 13) | interface Chainable<F extends TypeLambda> extends FlatMap<F>, Covariant<...

FILE: src/typeclass/Contravariant.ts
  type Contravariant (line 12) | interface Contravariant<F extends TypeLambda> extends Invariant<F> {

FILE: src/typeclass/Coproduct.ts
  type Coproduct (line 13) | interface Coproduct<F extends TypeLambda> extends SemiCoproduct<F> {

FILE: src/typeclass/Covariant.ts
  type Covariant (line 12) | interface Covariant<F extends TypeLambda> extends Invariant<F> {

FILE: src/typeclass/Equivalence.ts
  type Equivalence (line 24) | interface Equivalence<A> {
  type EquivalenceTypeLambda (line 32) | interface EquivalenceTypeLambda extends TypeLambda {

FILE: src/typeclass/Filterable.ts
  type Filterable (line 18) | interface Filterable<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/FlatMap.ts
  type FlatMap (line 11) | interface FlatMap<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/Foldable.ts
  type Foldable (line 15) | interface Foldable<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/Invariant.ts
  type Invariant (line 16) | interface Invariant<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/Monad.ts
  type Monad (line 12) | interface Monad<F extends TypeLambda> extends FlatMap<F>, Pointed<F> {}

FILE: src/typeclass/Monoid.ts
  type Monoid (line 12) | interface Monoid<A> extends Semigroup<A> {

FILE: src/typeclass/Of.ts
  type Of (line 10) | interface Of<F extends TypeLambda> extends TypeClass<F> {

FILE: src/typeclass/Order.ts
  type Order (line 20) | interface Order<A> {
  type OrderTypeLambda (line 28) | interface OrderTypeLambda extends TypeLambda {

FILE: src/typeclass/Pointed.ts
  type Pointed (line 12) | interface Pointed<F extends TypeLambda> extends Covariant<F>, Of<F> {}

FILE: src/typeclass/Product.ts
  type Product (line 13) | interface Product<F extends TypeLambda> extends SemiProduct<F>, Of<F> {

FILE: src/typeclass/SemiAlternative.ts
  type SemiAlternative (line 12) | interface SemiAlternative<F extends TypeLambda> extends SemiCoproduct<F>...

FILE: src/typeclass/SemiApplicative.ts
  type SemiApplicative (line 15) | interface SemiApplicative<F extends TypeLambda> extends SemiProduct<F>, ...

FILE: src/typeclass/SemiCoproduct.ts
  type SemiCoproduct (line 13) | interface SemiCoproduct<F extends TypeLambda> extends Invariant<F> {

FILE: src/typeclass/SemiProduct.ts
  type SemiProduct (line 14) | interface SemiProduct<F extends TypeLambda> extends Invariant<F> {
  type EnforceNonEmptyRecord (line 150) | type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R

FILE: src/typeclass/Semigroup.ts
  type Semigroup (line 17) | interface Semigroup<A> {
  type SemigroupTypeLambda (line 26) | interface SemigroupTypeLambda extends TypeLambda {

FILE: src/typeclass/Traversable.ts
  type Traversable (line 12) | interface Traversable<T extends TypeLambda> extends TypeClass<T> {

FILE: src/typeclass/TraversableFilterable.ts
  type TraversableFilterable (line 23) | interface TraversableFilterable<T extends TypeLambda> extends TypeClass<...

FILE: test/Either.ts
  type A (line 97) | type A = { readonly type: "A" }
  type B (line 98) | type B = { readonly type: "B" }
  type C (line 99) | type C = A | B

FILE: test/Option.ts
  type A (line 107) | type A = { readonly type: "A" }
  type B (line 108) | type B = { readonly type: "B" }
  type C (line 109) | type C = A | B
  type X (line 378) | interface X {
  type Direction (line 448) | type Direction = "asc" | "desc"

FILE: test/Predicate.ts
  type NonEmptyStringBrand (line 10) | interface NonEmptyStringBrand {
  type NonEmptyString (line 14) | type NonEmptyString = string & NonEmptyStringBrand
  type A (line 50) | type A = {

FILE: test/ReadonlyArray.ts
  type X (line 1233) | interface X {

FILE: test/index.ts
  function getModuleNames (line 13) | function getModuleNames(): ReadonlyArray<string> {

FILE: test/limbo/Category.ts
  type Category (line 11) | interface Category<F extends TypeLambda> extends Composable<F> {

FILE: test/limbo/Comonad.ts
  type Comonad (line 11) | interface Comonad<F extends TypeLambda> extends Extendable<F> {

FILE: test/limbo/Composable.ts
  type Composable (line 10) | interface Composable<F extends TypeLambda> extends TypeClass<F> {

FILE: test/limbo/Extendable.ts
  type Extendable (line 11) | interface Extendable<F extends TypeLambda> extends Covariant<F> {

FILE: test/limbo/NonEmptyTraversable.ts
  type NonEmptyTraversable (line 15) | interface NonEmptyTraversable<T extends TypeLambda> extends TypeClass<T> {

FILE: test/typeclass/Equivalence.ts
  type Person (line 22) | interface Person {
  type T (line 34) | type T = readonly [string, number, boolean]
  type T (line 52) | type T = readonly [string, number, boolean]

FILE: test/typeclass/NonEmptyTraversable.ts
  type NonEmptyReadonlyArrayTypeLambda (line 20) | interface NonEmptyReadonlyArrayTypeLambda extends TypeLambda {

FILE: test/typeclass/Order.ts
  type T (line 34) | type T = [number, string]
  type T (line 77) | type T = [number, string]
  type A (line 161) | type A = { a: number }
  type A (line 176) | type A = { a: number }

FILE: test/typeclass/Semigroup.ts
  type Item (line 44) | type Item = { a: number }
  type Item (line 60) | type Item = { a: number }