taskThese.getAlt(S).alt

[pbadenski]

Does this implementation make sense for TaskThese#alt implementation? Or maybe have I reinvented a wheel and can do this using existing method?

const altTaskThese = <E, A> (fa: taskThese.TaskThese<E, A>, fb: taskThese.TaskThese<E, A>, semigroup: semigroup.Semigroup<E>) => {
  return pipe(
    fa,
    taskThese.fold(
      e => pipe(fb, taskThese.fold(
        e2 => taskThese.left(semigroup.concat(e, e2)),
        a2 => taskThese.both(e, a2),
        (e2, a2) => taskThese.both(semigroup.concat(e, e2), a2)
      )),
      a => taskThese.right(a),
      (e, a) => taskThese.both(e, a)
    ));
};

[ammut]

I would probably try to separate these things a little bit. First define your These.alt:

// These.ts
import * as S from 'fp-ts/Semigroup';
import { isLeft, These, getSemigroup } from 'fp-ts/These';

export const theseGetAlt = <E>(s: S.Semigroup<E>) => {
  return <A>(b: Lazy<These<E, A>>) => {
    const sgt = getSemigroup(s, S.first<A>());
    return (a: These<E, A>): These<E, A> => (isLeft(a) ? sgt.concat(a, b()) : a);
  };
};

Then try to mirror the implementation of EitherT.alt:

// TheseT.ts
import * as S from 'fp-ts/Semigroup';
import { Monad } from 'fp-ts/Monad';
import { These } from 'fp-ts/These';
import { HKT } from 'fp-ts/HKT';

import { getAlt } from './These';

export const getAlt =
  <M>(M: Monad<M>) =>
  <E>(s: S.Semigroup<E>) =>
  <A>(second: Lazy<HKT<M, These<E, A>>>) => {
    const alt = theseGetAlt(s);
    return (first: HKT<M, These<E, A>>) =>
      M.chain(first, (t) =>
        isLeft(t) ? M.chain(second(), (t2) => M.of(alt(() => t2)(t))) : M.of(t),
      );
  };

And finally inject Task.Monad:

// TaskThese.ts
import * as Task from 'fp-ts/Task';

import * as TheseT from './TheseT';

export const getAlt = TheseT.getAlt(Task.Monad);

However, be aware that this is your definition of what an alt over These is, as there is apparently no consensus - or at least nothing in fp-ts. Also, one remark: It looks like you're doing almost the same thing as <E>(s: S.Semigroup<E>) => These.getSemigroup(s, S.first), but when a is a right, you ignore b completely, instead of always concatenating E, is that what you want? This seems less like an alt to me and more like a concat...

[ammut]

After thinking about this a bit more, you are probably doing too much for an alt here. Looking at Either.alt, it is just (fa) => (that) => isLeft(fa) ? that() : fa, no concatenation of E or anything like that. That implementation can also be used verbatim for These.

If anything at all, you could make These.alt more strict: (fa) => (that) => isRight(fa) ? fa : that(), but from reading These.getApply and These.getSemigroup I feel like that kind of goes against the spirit of These.

Meaning TaskThese.alt becomes pretty simple:

export const theseAltW: <E2, B>(that: Lazy<These<E2, B>>) => <E1, A>(fa: These<E1, A>) => These<E1 | E2, A | B> =
  (that) => (fa) => isLeft(fa) ? that() : fa;
export const theseAlt: <E, A>(that: Lazy<These<E2, B>>) => (fa: These<E, A>) => These<E, A> = theseAltW;

export const theseTAlt =
  <M>(M: Monad<M>) =>
  <A>(second: Lazy<HKT<M, These<E, A>>>) =>
  (first: HKT<M, These<E, A>>) =>
    M.chain(first, (t) => isLeft(t) ? second() : M.of(t));

export const taskTheseAlt = theseTAlt(Task.Monad);

However, this really isn't what you described in your question, and if you do want/need what you described, I would suggest you call it a Semigroup instead of an Alt and use the solution of my previous answer.