Question

我有一个Either类型，用于表示Failure和Success的值，我想编写一个函数，该函数需要任意数量的Either并返回序列中的第一个Failure或一个新的Success，其值是未包装的Success值的元组。行为类似于Promise.all()。

我认为我已经使用混合了条件类型和映射类型的类型来进行此工作，但是我很难实现实际功能来完成工作。我不确定如何将输入的类型推断为任意长度的Either s元组。我仍然是TypeScript的新手，请多多包涵，让我知道是否有更好/更惯用的方式来做某事。

这是我到目前为止（和TypeScript Playground Link）所拥有的：

type Either<E, T> = Failure<E, T> | Success<E, T>;

type Union<T> = 
  T extends Array<infer U> ? U :
  T extends { [index: string]: infer U } ? U :
  never;

type FailureType<T> = T extends Failure<infer U, infer V> ? U : never;
type SuccessType<T> = T extends Success<infer U, infer V> ? V : never;

type FailureTypesUnion<T> = Union<{ [K in keyof T]: FailureType<T[K]> }>;
type SuccessTypesAggregate<T> = { [K in keyof T]: SuccessType<T[K]> };

// This type represents the result type that `Result.sequence` should have.
type EitherTypesSequence<T> = Either<FailureTypesUnion<T>, SuccessTypesAggregate<T>>;

// this gives the desired type: 
// `type Test = Failure<string | number | boolean> | Success<[boolean, string, number]>`
type Test = EitherTypesSequence<
  [
    Either<string, boolean>,
    Either<number, string>,
    Either<boolean, number>
  ]
>

class Result {
  public static Ok<E, T>(value: T): Either<E, T> {
    return new Success(value);
  }

  public static Err<E, T>(error: E): Either<E, T> {
    return new Failure(error);
  }

  public static isSuccess<E, T>(target: Either<E, T>): target is Success<E, T> {
    return target instanceof Success;
  }

  public static isFailure<E, T>(target: Either<E, T>): target is Failure<E, T> {
    return target instanceof Failure;
  }

  public static sequence(
    // ...args: ???
    // How do I constrain the input to this function to be an array of Eithers?
    // How to I infer the types of the Eithers as a tuple?
  ) {
    // How wold I implement an angorithm here that plays nice with the types above?
  }
}

// A Success class that represents the `right` path
class Success<E, T> {
  private _value: T;

  constructor(value: T) {
    this._value = value;
  }

  public map<U>(fn: (v: T) => U): Either<E, U> {
    return new Success(fn(this._value));
  }

  public chain<U, V>(fn: (v: T) => Either<U, V>): Either<E | U, V> {
    return fn(this._value);
  }

  public either<U, V>(onFailure: (v: E) => U, onSuccess: (v: T) => V): U | V {
    return onSuccess(this._value);
  }

  public get(): T {
    return this._value;
  }
}

// A Failure class that represents the `left` path
class Failure<E, T> {
  private _value: E;

  constructor(error: E) {
    this._value = error;
  }

  public map<U>(fn: (v: T) => U): Either<E, U> {
    return new Failure(this._value);
  }

  public chain<U, V>(fn: (v: T) => Either<U, V>): Either<E | U, V> {
    return new Failure(this._value);
  }

  public either<U, V>(onFailure: (v: E) => U, onSuccess: (v: T) => V): U | V {
    return onFailure(this._value);
  }

  public get(): E {
    return this._value;
  }
}

任何帮助，我们将不胜感激。

Answer 1

丰富的元组来自打字稿3.1？ 3.2？我不记得了；但是现在有了它们，所有函数参数都可以表示为元组（元组已经散布，可选参数就像函数一样）。

您可以像执行类似这样的操作以元组的形式获取输入。

如果您给我有关返回类型的更多信息，我也可以帮助您。

interface Either<A> {
    type: A
}

const sequence = <T extends Either<any>[]>(...args: T): T => {
    // don't know whats supposed to be here till you tell me more.
    return "" as any; // placeholder;
}


declare const EitherNumber: Either<number>;
declare const EitherString: Either<string>;
declare const EitherDate: Either<Date>;
const whatType = sequence(EitherNumber, EitherString, EitherDate) // [EitherNumber, EitherString, EitherDate] (tuple)

更新后，它看起来像是留了一个“我不知道这里的字符串是关于我缺少什么的地方，也许您可以填空，但这只是它。

type Success<E, T> = {e: E, t: T}; // doesn't matter but i don't understand two type parameters.
type Failure<E, T> = {e: E, t: T}; // doesn't matter but i dont understand two type parameters
type Either<E, T> = Failure<E, T> | Success<E, T>;
declare const EitherOne: Either<string, boolean>;
declare const EitherTwo: Either<number, string>;
declare const EitherThree: Either<boolean, number>;


type MapRight<T extends Either<any, any>[]> = {
    [K in keyof T]: T[K] extends Either<any, infer Right> ? Right : never;
}
type GetLeft<T extends Either<any, any>> = [T] extends [Either<infer Left, infer Right>] ? Failure<Left, Right> : never;
const sequence = <T extends Either<any, any>[]>(...args: T): GetLeft<T[number]>  | Success<"Dont Know what goes here", MapRight<T>>=> {
    // don't know whats supposed to be here till you tell me more.
    return "" as any; // placeholder;
}

const combined = sequence(EitherOne, EitherTwo, EitherThree); // Failure<string | number | boolean> | Success<"I dont know what goes here", [boolean, string, number]>

认为这是对的。最终编辑。

type Success<E, T> = {e: E, t: T}; // doesn't matter but i don't understand two type parameters.
type Failure<E, T> = {e: E, t: T}; // doesn't matter but i dont understand two type parameters
type Either<E, T> = Failure<E, T> | Success<E, T>;
declare const EitherOne: Either<string, boolean>;
declare const EitherTwo: Either<number, string>;
declare const EitherThree: Either<boolean, number>;


type MapRight<T extends Either<any, any>[]> = {
    [K in keyof T]: T[K] extends Either<any, infer Right> ? Right : never;
}
type GetRight<T extends Either<any, any>> = T extends Either<any, infer Right> ? Right : never;
type GetLeft<T extends Either<any, any>> = T extends Either<infer Left, any> ? Left : never;
const sequence = <T extends Either<any, any>[]>
    (...args: T): Failure<GetLeft<T[number]>, GetRight<T[number]>> | Success<GetLeft<T[number]>, MapRight<T>> => {
    // don't know whats supposed to be here till you tell me more.
    return "" as any; // placeholder;
}

const combined = sequence(EitherOne, EitherTwo, EitherThree); // Failure<string | number | boolean> | Success<string | number | boolean, [boolean, string, number]>

将Eithers数组映射到值数组的Either

1 个答案: