<
Self,
K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>,
A
>(
...args:
| [self: Self, body: (this: Self) => Generator<K, A, never>]
| [body: () => Generator<K, A, never>]
): Kind<
F,
[K] extends [Variance<F, infer R, any, any>]
? R
: [K] extends [Kind<F, infer R, any, any, any>]
? R
: never,
[K] extends [Variance<F, any, infer O, any>]
? O
: [K] extends [Kind<F, any, infer O, any, any>]
? O
: never,
[K] extends [Variance<F, any, any, infer E>]
? E
: [K] extends [Kind<F, any, any, infer E, any>]
? E
: never,
A
>Type-level signature for generator-based monadic composition over any
TypeLambda.
When to use
Use to type the gen function of a module that supports generator syntax,
such as Option.gen, Result.gen, and Effect.gen.
Details
This is a pure type alias with no runtime behavior. It infers R, O, and
E from the yielded values via Variance or Kind constraints. The
generator's return type A becomes the output's A parameter.
Example (Typing a gen function for Option)
import type { Option, Utils } from "effect"
declare const gen: Utils.Gen<Option.OptionTypeLambda>export type type Gen<F extends TypeLambda> = <
Self,
K extends
| Variance<F, any, any, any>
| Kind<F, any, any, any, any>,
A
>(
...args:
| [
self: Self,
body: (
this: Self
) => Generator<K, A, never>
]
| [body: () => Generator<K, A, never>]
) => Kind<
F,
[K] extends [Variance<F, infer R, any, any>]
? R
: [K] extends [
Kind<F, infer R, any, any, any>
]
? R
: never,
[K] extends [Variance<F, any, infer O, any>]
? O
: [K] extends [
Kind<F, any, infer O, any, any>
]
? O
: never,
[K] extends [Variance<F, any, any, infer E>]
? E
: [K] extends [
Kind<F, any, any, infer E, any>
]
? E
: never,
A
>
Type-level signature for generator-based monadic composition over any
TypeLambda.
When to use
Use to type the gen function of a module that supports generator syntax,
such as Option.gen, Result.gen, and Effect.gen.
Details
This is a pure type alias with no runtime behavior. It infers R, O, and
E from the yielded values via
Variance
or Kind constraints. The
generator's return type A becomes the output's A parameter.
Example (Typing a gen function for Option)
import type { Option, Utils } from "effect"
declare const gen: Utils.Gen<Option.OptionTypeLambda>
Gen<function (type parameter) F in type Gen<F extends TypeLambda>F extends TypeLambda> = <
function (type parameter) Self in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>Self,
function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K extends interface Variance<in out F extends TypeLambda, in R, out O, out E>Type-level marker encoding the variance of a TypeLambda's type
parameters.
When to use
Use to define variance constraints for a higher-kinded type so that
Gen
can correctly infer R, O, and E from yielded values.
Details
F is invariant and must match exactly. R is contravariant in the input
or environment position. O and E are covariant in the output and error
positions. This is a pure type-level construct with no runtime
representation.
Example (Declaring variance for a TypeLambda)
import type { Option, Utils } from "effect"
declare const variance: Utils.Variance<
Option.OptionTypeLambda,
never,
never,
never
>
Variance<function (type parameter) F in type Gen<F extends TypeLambda>F, any, any, any> | type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
readonly type: unknown;
} ? (F & {
readonly In: In;
readonly Out2: Out2;
readonly Out1: Out1;
readonly Target: Target;
})["type"] : {
readonly F: F;
readonly In: Types.Contravariant<In>;
readonly Out2: Types.Covariant<Out2>;
readonly Out1: Types.Covariant<Out1>;
readonly Target: Types.Invariant<Target>;
}
Applies type parameters to a TypeLambda to get the concrete type.
When to use
Use to apply a TypeLambda to type parameters and obtain its concrete type.
Details
This type-level function takes a TypeLambda and four type parameters, then
"applies" them to get the actual type. It handles variance correctly, ensuring
contravariant parameters are used as inputs and covariant parameters as
outputs. This is the core mechanism that allows HKT to transform abstract type
constructors into concrete types by applying arguments.
Example (Applying type lambdas)
import type { Effect, HKT, Option } from "effect"
// Define TypeLambdas
interface OptionTypeLambda extends HKT.TypeLambda {
readonly type: Option.Option<this["Target"]>
}
interface EffectTypeLambda extends HKT.TypeLambda {
readonly type: Effect.Effect<this["Target"], this["Out2"], this["Out1"]>
}
// Apply type parameters to get concrete types
type OptionString = HKT.Kind<OptionTypeLambda, never, never, never, string>
// Result: Option.Option<string>
type EffectStringNumberBoolean = HKT.Kind<
EffectTypeLambda,
never,
number,
boolean,
string
>
// Result: Effect.Effect<string, number, boolean>
// TypeLambdas enable generic programming over type constructors
type StringType<F extends HKT.TypeLambda> = HKT.Kind<
F,
never,
never,
never,
string
>
Kind<function (type parameter) F in type Gen<F extends TypeLambda>F, any, any, any, any>,
function (type parameter) A in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>A
>(
...args: | [
self: Self,
body: (this: Self) => Generator<K, A, never>
]
| [body: () => Generator<K, A, never>]
Selfself: function (type parameter) Self in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>Self,
function (this: Self) => Generator<K, A, never>body: (this: Selfthis: function (type parameter) Self in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>Self) => interface Generator<T = unknown, TReturn = any, TNext = any>Generator<function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K, function (type parameter) A in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>A, never>
]
| [
function () => Generator<K, A, never>body: () => interface Generator<T = unknown, TReturn = any, TNext = any>Generator<function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K, function (type parameter) A in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>A, never>
]
) => type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
readonly type: unknown;
} ? (F & {
readonly In: In;
readonly Out2: Out2;
readonly Out1: Out1;
readonly Target: Target;
})["type"] : {
readonly F: F;
readonly In: Types.Contravariant<In>;
readonly Out2: Types.Covariant<Out2>;
readonly Out1: Types.Covariant<Out1>;
readonly Target: Types.Invariant<Target>;
}
Applies type parameters to a TypeLambda to get the concrete type.
When to use
Use to apply a TypeLambda to type parameters and obtain its concrete type.
Details
This type-level function takes a TypeLambda and four type parameters, then
"applies" them to get the actual type. It handles variance correctly, ensuring
contravariant parameters are used as inputs and covariant parameters as
outputs. This is the core mechanism that allows HKT to transform abstract type
constructors into concrete types by applying arguments.
Example (Applying type lambdas)
import type { Effect, HKT, Option } from "effect"
// Define TypeLambdas
interface OptionTypeLambda extends HKT.TypeLambda {
readonly type: Option.Option<this["Target"]>
}
interface EffectTypeLambda extends HKT.TypeLambda {
readonly type: Effect.Effect<this["Target"], this["Out2"], this["Out1"]>
}
// Apply type parameters to get concrete types
type OptionString = HKT.Kind<OptionTypeLambda, never, never, never, string>
// Result: Option.Option<string>
type EffectStringNumberBoolean = HKT.Kind<
EffectTypeLambda,
never,
number,
boolean,
string
>
// Result: Effect.Effect<string, number, boolean>
// TypeLambdas enable generic programming over type constructors
type StringType<F extends HKT.TypeLambda> = HKT.Kind<
F,
never,
never,
never,
string
>
Kind<
function (type parameter) F in type Gen<F extends TypeLambda>F,
[function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [interface Variance<in out F extends TypeLambda, in R, out O, out E>Type-level marker encoding the variance of a TypeLambda's type
parameters.
When to use
Use to define variance constraints for a higher-kinded type so that
Gen
can correctly infer R, O, and E from yielded values.
Details
F is invariant and must match exactly. R is contravariant in the input
or environment position. O and E are covariant in the output and error
positions. This is a pure type-level construct with no runtime
representation.
Example (Declaring variance for a TypeLambda)
import type { Option, Utils } from "effect"
declare const variance: Utils.Variance<
Option.OptionTypeLambda,
never,
never,
never
>
Variance<function (type parameter) F in type Gen<F extends TypeLambda>F, infer function (type parameter) RR, any, any>] ? function (type parameter) RR
: [function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
readonly type: unknown;
} ? (F & {
readonly In: In;
readonly Out2: Out2;
readonly Out1: Out1;
readonly Target: Target;
})["type"] : {
readonly F: F;
readonly In: Types.Contravariant<In>;
readonly Out2: Types.Covariant<Out2>;
readonly Out1: Types.Covariant<Out1>;
readonly Target: Types.Invariant<Target>;
}
Applies type parameters to a TypeLambda to get the concrete type.
When to use
Use to apply a TypeLambda to type parameters and obtain its concrete type.
Details
This type-level function takes a TypeLambda and four type parameters, then
"applies" them to get the actual type. It handles variance correctly, ensuring
contravariant parameters are used as inputs and covariant parameters as
outputs. This is the core mechanism that allows HKT to transform abstract type
constructors into concrete types by applying arguments.
Example (Applying type lambdas)
import type { Effect, HKT, Option } from "effect"
// Define TypeLambdas
interface OptionTypeLambda extends HKT.TypeLambda {
readonly type: Option.Option<this["Target"]>
}
interface EffectTypeLambda extends HKT.TypeLambda {
readonly type: Effect.Effect<this["Target"], this["Out2"], this["Out1"]>
}
// Apply type parameters to get concrete types
type OptionString = HKT.Kind<OptionTypeLambda, never, never, never, string>
// Result: Option.Option<string>
type EffectStringNumberBoolean = HKT.Kind<
EffectTypeLambda,
never,
number,
boolean,
string
>
// Result: Effect.Effect<string, number, boolean>
// TypeLambdas enable generic programming over type constructors
type StringType<F extends HKT.TypeLambda> = HKT.Kind<
F,
never,
never,
never,
string
>
Kind<function (type parameter) F in type Gen<F extends TypeLambda>F, infer function (type parameter) RR, any, any, any>] ? function (type parameter) RR
: never,
[function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [interface Variance<in out F extends TypeLambda, in R, out O, out E>Type-level marker encoding the variance of a TypeLambda's type
parameters.
When to use
Use to define variance constraints for a higher-kinded type so that
Gen
can correctly infer R, O, and E from yielded values.
Details
F is invariant and must match exactly. R is contravariant in the input
or environment position. O and E are covariant in the output and error
positions. This is a pure type-level construct with no runtime
representation.
Example (Declaring variance for a TypeLambda)
import type { Option, Utils } from "effect"
declare const variance: Utils.Variance<
Option.OptionTypeLambda,
never,
never,
never
>
Variance<function (type parameter) F in type Gen<F extends TypeLambda>F, any, infer function (type parameter) OO, any>] ? function (type parameter) OO
: [function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
readonly type: unknown;
} ? (F & {
readonly In: In;
readonly Out2: Out2;
readonly Out1: Out1;
readonly Target: Target;
})["type"] : {
readonly F: F;
readonly In: Types.Contravariant<In>;
readonly Out2: Types.Covariant<Out2>;
readonly Out1: Types.Covariant<Out1>;
readonly Target: Types.Invariant<Target>;
}
Applies type parameters to a TypeLambda to get the concrete type.
When to use
Use to apply a TypeLambda to type parameters and obtain its concrete type.
Details
This type-level function takes a TypeLambda and four type parameters, then
"applies" them to get the actual type. It handles variance correctly, ensuring
contravariant parameters are used as inputs and covariant parameters as
outputs. This is the core mechanism that allows HKT to transform abstract type
constructors into concrete types by applying arguments.
Example (Applying type lambdas)
import type { Effect, HKT, Option } from "effect"
// Define TypeLambdas
interface OptionTypeLambda extends HKT.TypeLambda {
readonly type: Option.Option<this["Target"]>
}
interface EffectTypeLambda extends HKT.TypeLambda {
readonly type: Effect.Effect<this["Target"], this["Out2"], this["Out1"]>
}
// Apply type parameters to get concrete types
type OptionString = HKT.Kind<OptionTypeLambda, never, never, never, string>
// Result: Option.Option<string>
type EffectStringNumberBoolean = HKT.Kind<
EffectTypeLambda,
never,
number,
boolean,
string
>
// Result: Effect.Effect<string, number, boolean>
// TypeLambdas enable generic programming over type constructors
type StringType<F extends HKT.TypeLambda> = HKT.Kind<
F,
never,
never,
never,
string
>
Kind<function (type parameter) F in type Gen<F extends TypeLambda>F, any, infer function (type parameter) OO, any, any>] ? function (type parameter) OO
: never,
[function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [interface Variance<in out F extends TypeLambda, in R, out O, out E>Type-level marker encoding the variance of a TypeLambda's type
parameters.
When to use
Use to define variance constraints for a higher-kinded type so that
Gen
can correctly infer R, O, and E from yielded values.
Details
F is invariant and must match exactly. R is contravariant in the input
or environment position. O and E are covariant in the output and error
positions. This is a pure type-level construct with no runtime
representation.
Example (Declaring variance for a TypeLambda)
import type { Option, Utils } from "effect"
declare const variance: Utils.Variance<
Option.OptionTypeLambda,
never,
never,
never
>
Variance<function (type parameter) F in type Gen<F extends TypeLambda>F, any, any, infer function (type parameter) EE>] ? function (type parameter) EE
: [function (type parameter) K in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>K] extends [type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
readonly type: unknown;
} ? (F & {
readonly In: In;
readonly Out2: Out2;
readonly Out1: Out1;
readonly Target: Target;
})["type"] : {
readonly F: F;
readonly In: Types.Contravariant<In>;
readonly Out2: Types.Covariant<Out2>;
readonly Out1: Types.Covariant<Out1>;
readonly Target: Types.Invariant<Target>;
}
Applies type parameters to a TypeLambda to get the concrete type.
When to use
Use to apply a TypeLambda to type parameters and obtain its concrete type.
Details
This type-level function takes a TypeLambda and four type parameters, then
"applies" them to get the actual type. It handles variance correctly, ensuring
contravariant parameters are used as inputs and covariant parameters as
outputs. This is the core mechanism that allows HKT to transform abstract type
constructors into concrete types by applying arguments.
Example (Applying type lambdas)
import type { Effect, HKT, Option } from "effect"
// Define TypeLambdas
interface OptionTypeLambda extends HKT.TypeLambda {
readonly type: Option.Option<this["Target"]>
}
interface EffectTypeLambda extends HKT.TypeLambda {
readonly type: Effect.Effect<this["Target"], this["Out2"], this["Out1"]>
}
// Apply type parameters to get concrete types
type OptionString = HKT.Kind<OptionTypeLambda, never, never, never, string>
// Result: Option.Option<string>
type EffectStringNumberBoolean = HKT.Kind<
EffectTypeLambda,
never,
number,
boolean,
string
>
// Result: Effect.Effect<string, number, boolean>
// TypeLambdas enable generic programming over type constructors
type StringType<F extends HKT.TypeLambda> = HKT.Kind<
F,
never,
never,
never,
string
>
Kind<function (type parameter) F in type Gen<F extends TypeLambda>F, any, any, infer function (type parameter) EE, any>] ? function (type parameter) EE
: never,
function (type parameter) A in <Self, K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(...args: [self: Self, body: (this: Self) => Generator<K, A, never>] | [body: () => Generator<K, A, never>]): Kind<F, [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never, [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never, [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never, A>A
>