Struct of These

[florianbepunkt]

Given a structure where each property is of type These<E, A> where E and A are different for each prop.

declare const someStruct: {
    a1: TH.These<E1, A1>;
    a2: TH.These<E2, A2>;
    a3: TH.These<E3, A3>;
}

I'm treating These like this:

• left: critical error, computation failed
• right: successful computation
• both: minor error/warning, continue computation

Now I'm looking for a way to combine results of a struct like the one above. Basically I want to do a sequenceS(UNKNOWN_APPLY)(someStruct) that returns a TH.These<Array<E1 | E2 | E3>, RIGHT_VALUES of someStruct>.

Approach

const someStruct = {
a1: TH.right(1),
a2: TH.left('foo'),
a3: TH.both(10, 'foobar'),
};

function getLastSemigroup<A = never>(): SG.Semigroup {
return { concat: (x, y) => y };
}

const apply = TH.getApply<string | number>(getLastSemigroup());
const f = sequenceS(apply)(struct);

pipe(
f,
TH.map((s) => s.b), // b also incluces a2 of type never which is undesirable
TH.mapLeft(e => e) // this only gives me the last warning/error, while I would like to retain all left values
);

Edited for clarity

[ammut]

There's two issues here, from what I can tell. First, in TH.map((s) => ...), s is { a1: number; a2: never; a3: string }, including the irksome a2: never. You could use a helper type like this:

type FilterNeverKeys<K extends keyof S, S> = K extends unknown ? S[K] extends never ?  never : K : never;
type FilterNeverS<S> = { [K in FilterNeverKeys<keyof S, S>]: S[K] };

// use like this
const filterNever = <S extends Record<string, unknown>>(s: S): FilterNeverS<S> => s;
pipe(
  someStruct,
  sequenceS(TH.getApply(SG.last())),
  TH.map(filterNever),
  TH.map((s) => s.a2), // Error: property 'a2' does not exist on type
);

to filter out the props with type never, but do you actually need this? I would assume most of the time you have a These<E, A>, and rarely if ever a These<E, never>. The compiler just knows that a2 is never because that is how you created your test data.

For the second point you're missing one crucial step. How are you going to retain all the left values, if your E is just string | number? You can't, obviously, because you'll need a collection for that, i.e. an Array<E> in most cases. This is also sometimes called a Validation, usually expressed as Either<Array<E>, A>. And then it's clear that you need another semigroup, namely Array.getSemigroup<E>(). So:

const someStruct = {
  a1: TH.right(1),
  a2: TH.left(['foo']),
  a3: TH.both([10], 'foobar'),
};

pipe(
  someStruct,
  AP.sequenceS(TH.getApply(Array.getSemigroup<string | number>())),
  x => console.log(x), // { left: ['foo', 10] }
);

If you can't control how your These<E, A> are produced, you can map the individual values with TH.mapLeft(Array.of) first.

Also, just for reference, here's how TH.getApply behaves:

These.getApply(S).ap(fab, fa)

fab \ fa	left	right	both
left	left(S.concat(fab.left, fa.left)	left(fab.left)	left(S.concat(fab.left, fa.left))
right	left(fa.left)	right(fab.right(fa.right))	both(fa.left, fab.right(fa.right))
both	left(S.concat(fab.left, fa.left))	both(fab.left, fab.right(fa.right))	both(S.concat(fab.left, fa.right), fab.right(fa.right))

Which is what you want: If even a single fa is a left, you won't be able to recover, and you'll end up with a left, which includes all errors, minor and major. If all your 'fa's are right, you'll end up with a right, and if some of them are both you'll end up with a both, something like { left: [... errors ...], right: { a1: 1, a2: 'foobar' } }.

[florianbepunkt]

Thank you