fix: fixed chainFirst returning Left result of chained method

[DevNico]

Closes #46

[DevNico]

You should probably add a fail call everywhere you do a match to expect something in either left or right cases since this way tests that should fail, pass.

[SandroMaglione]

Hi @DevNico

Good catch! You are right, chainFirst is incorrect when chaining fails.

Would you mind fixing chainFirst also in the other types? Namely:

• Either
• TaskEither
• Monad
• State
• StateAsync
• Reader
• IOEither

[DevNico]

I fixed the IOEither case. I have no experience using those other types and don't see them being broken just by looking at the code. If there is something wrong with the code there I suggest you fix it.

[SandroMaglione]

Great, thanks again for your contribution and suggestion 👍

[rd-martin-jaeger]

Hi @SandroMaglione @DevNico,

i have a general question about the function, regardless of how it is currently described in the documentation.
Shouldn't chainFirst() actually be able to return any failures instead of ignoring them?

Thats at least what i would expect when i start to chain eithers or did i miss the point, where it totally makes sense to ignore them within you chained functions?

Consequently, the previous solution would actually have been the right one for me.

flatMap((b) => chain(b).map((c) => b));

group('chainFirst', () {
    test('Right', () async {
     final task = TaskEither<String, int>.of(10);

     final chain = task.chainFirst((b) => TaskEither.right(100));

     final result = await chain.run();

     result.match(
       (l) => fail('should be right'),
       (r) => expect(r, 10),
     );
   });

   group('Left', () async {
     final task = TaskEither<String, int>.of(10);

     final chain = task.chainFirst((b) => TaskEither.left('none'));

     final result = await chain.run();

     result.match(
       (l) => expect(l, 'none'),
       (r) => fail('should be left'),
     );
   });
 });

[SandroMaglione]

Hi @rd-martin-jaeger

If you need to return any failure you should use flatMap. chainFirst instead is used precisely for ignoring: you chain some computations without collecting its result.