[Feature Request] Merge fields, Result.combine but for objects

[JesseGovindan]

I think it would be useful to have a mergeFields method similar to Result.combine but which works with object fields

Usage:

const result = mergeFields({
  length: parseLength(lengthString), // returns Result<number, 'InvalidLengthString'>
  width: parseWidth(widthString), // returns Result<number, 'InvalidWidthString'>
})

// type of result is Result<{ length: number, width: number }, 'InvalidLengthString' | 'InvalidWidthString>

Possible implementation:

type ExtractOk<T extends Result<unknown, unknown>> = T extends Result<infer U, unknown> ? U : never
type ErrorUnion<U> = U[keyof U] extends Result<any, infer E> ? E : never;

export function mergeFields<R, E, U extends Record<string, Result<R, E>>>(results: U)
: Result<
  { [K in keyof U]: ExtractOk<U[K]> },
  ErrorUnion<U>
> {
  const unwrapped: Partial<Record<string, unknown>> = {};

  for (const key of Object.keys(results) as Array<keyof U>) {
    const r = results[key] as Result<unknown, ErrorUnion<U>>;
    if (r.isErr()) {
      return err(r.error);
    }
    unwrapped[key as string] = r.value;
  }

  return ok({
    ...(unwrapped as { [K in keyof U]: ExtractOk<U[K]> }),
  } as { [K in keyof U]: ExtractOk<U[K]> });
}

[macksal]

An implementation of this is in PR here: #610

I do think it makes more sense as an overload of Result.combine though i.e. make it work for either objects or arrays/tuples.

[JesseGovindan]

Apologies for not seeing that PR, my only objection to it being an overload of Result.combine would be that it would be a natural extension to this method to possibly take a 2nd parameter which is just a regular object, which gets merged into the result. This would prevent having to duplicate values from an existing object and make them all ok

i.e

const somePriorResult = {
  foo: true,
  bar: 23,
}

const newResult = mergeFields({
  baz: parseValue(rawValue), // returns Result<number, 'SomeError'>
}, somePriorResult)

// typeof newResult is Result<{ foo: true, bar: number, baz: number }, 'SomeError'>

as compared to

const somePriorResult = {
  foo: true,
  bar: 23,
}

const newResult = mergeFields({
  foo: ok(somePriorResult.foo),
  bar: ok(somePriorResult.bar),
  baz: parseValue(rawValue),
})
```

[macksal]

I don't think an overload locks us out from that expansion @JesseGovindan. It would just be added to the overload taking an object.

For what it's worth, I don't think that would be a logical extension of the method. You can quite easily merge your existing values separately to calling this new Result.combine. And if necessary, a user could define mergeFields in their own code as an inline of the below:

function parseValue(...): Result<number, 'SomeError'> {
	...
}

const somePriorResult = {
 	foo: true,
 	bar: 23,
};

const newResult = Result.combine({baz: parseValue(rawValue)}).map(result => ({...result, ...somePriorResult}));

[JesseGovindan]

I see what you mean. Great points @macksal. I agree, should be fine as overload of combine without requiring the 2nd argument

[Karibash]

@JesseGovindan @macksal
Since many PRs and issues in neverthrow have been left unattended and no further improvements seemed likely, we decided to create a new library.
Please give it a try if you’re interested — it includes all the APIs that neverthrow provides.
https://praha-inc.github.io/byethrow/