Hello! First of all, Thank you for your amazing work! I'm using fpdart with flutter. I have a quick question. Can I use Option.map for side effect? I think It will be working. But I'm not sure that.

final optionValue = Option.of(true);
optionValue.map((value) {
  print(value);
})

As the examples for Option. It's better that use match for side effect. But I don't need a None case.

final optionValue = Option.of(true);
optionValue.match(
  () => null,
  (value) => print(value),
);

Which one is better?

Hello! It would be great if there was a way to extract/unwrap the value contained in the Option and Either types. The unwrap terminology is used in Rust, and given that Dart is not a pure functional language sometimes it's useful to extract the value once you've checked it with isSome or isRight to do early returns. For instance say you return Left and you want to launch an error dialog (Flutter). You would want to break the flow of the program to show this dialog, else continue with the regular flow unwrapping the value of Right.

Here is the API in Rust for reference For Rust Option -> https://doc.rust-lang.org/std/option/#extracting-the-contained-value For Rust Result (equivalent to Either) -> https://doc.rust-lang.org/std/result/#extracting-contained-values

Hi, I have a question, as I am quite new to Functional programming and even imperative programming too.

Let's say I have something like this

class FirstException implements Exception {}

class SecondException implements Exception {}

class Student {
  final String name;
  Student(this.name);
}

class StudentRepo {
  static Future<List<Student>> getAllStudents() async => [
        Student('Juan'),
        Student('Maria'),
      ];
}

The question is how to handle only particular exception with tryCatch. In this case, I want to throw exception other than FirstException and SecondException because I heard catching all exceptions and errors are not good practice. But I am not sure how to handle this with functional way.

Imperative way:

Future<Either<String, List<Student>>> imperative() async {
  try {
    final students = await StudentRepo.getAllStudents();
    return right(students);
  } on FirstException {
    return left('FirstException');
  } on SecondException {
    return left('SecondException');
  }
  // I want to throw exception other than FirstException and SecondException
  // I want to avoid catch all exceptions without on clause
  // catch (e) {
  //   print(e);
  // }
}

Functional way:

TaskEither<String, List<Student>> getStudents = TaskEither.tryCatch(
  () => StudentRepo.getAllStudents(),
  (e, s) => // how to handle exception here?
);

Sorry, I may have misunderstood the concept of functional programming and this may be a dumb question. Anyway, thank you for creating this wonderful package and very detailed documentation.

Fixes #41 Mixins will no longer be able to extend other mixins (Rather the super mixin should be specified in an on clause). This breaking change is already on flutter's master channel, which is causing build errors when depending on this library. https://github.com/dart-lang/sdk/issues/48167

This change makes the mixin clause longer for many of the classes, but at least the tests seem to still pass. Other than one test which I'm assuming is related to this issue, which is already resolved on dart's master channel. https://github.com/dart-lang/sdk/commit/abedfaf62a2a426d44142dc97aa342524feedf8f

What about we have Tuple3-6 or 8 as in this package https://pub.dev/packages/tuple. I can still do something hacky like Tuple2<First, Tuple2<Second, Third>> but it will be not very friendly.

Hi!

Any plans to support Predicate and composing predicates?

Predicate:

typedef Predicate<E> = bool Function(E element);

composition:

var Predicate<File> isEmpty;
var Predicate<File> modifiedToday;
files.where(isEmpty && modifiedToday);

I had the problems with darts already and thought you might have a solution for that. How do I test an Either List type? Let's say I have the following simple test:

import 'package:flutter_test/flutter_test.dart';
import 'package:fpdart/fpdart.dart';

void main() {
  String expectedLeft = "lefti";
  List<int> expectedRight = [1, 2, 3, 4, 5];

  group("test either", () {
    test("test left", () {
      final res = getExpected(true);
      expect(res, Left(expectedLeft));
    });

    test("test right", () {
      final res = getExpected(false);
      expect(res, Either.right(expectedRight));
    });
  });
}

Either<String, List<int>> getExpected(bool isLeft) {
  if (isLeft) {
    return Left("lefti");
  } else {
    return Right([1, 2, 3, 4, 5]);
  }
}

The second test failed, because of the deep list inequality (or no deep list equality test).

How do you test this scenario in a simple manner?

Hi, i'm stuck in one part of my code, the thing is, my database provider brings me a Future<Map<String, Object>?>, so, i was trying to transform to TaskOption<Map<String, Object>> with not sucess, the only thing i've come to, is Task<Option<Map...>> .

The closest approach is this code but it's not the best for me.

late Future<Map<String,Object>?> example;
final taskOp = TaskOption.flatten((TaskOption.fromTask(Task(example).map((ex) => Option.fromNullable(ex).toTaskOption()))));

Is there any other alternative to get a TaskOption<T> object easily from Future?

Thanks a lot, your work in this library is excellent 💯 and sorry foy my bad english 😢

Context

Coming from a fp-ts background, I'm accustomed to be able to perform operations like sequenceT:

const prog = pipe(
  arrayOfItems.map((item) => {
    return TE.tryCatch(
      async () => {
        return await fetch(`/some/api?input=${item}`);
      },
      (e) => new Error('Error')
    );
  }),
  TE.sequenceT
);

In other words, maybe I need to hit an API multiple times with a bunch of inputs, so this is an array of TaskEithers, but at the end of the day, I just want to abstract that out, await this task once, and get back the array of responses.

I looked through the library for quite a long time and couldn't find anything like that in there yet, so I presumed that it's either called something else, or can be constructed somehow using Dart type magic, or just hasn't been implemented yet.

Approach

I'm quite new to Dart and am not fully up to speed with the Type system yet.

My understanding is that a better long-term solution is to implement some kind of abstract interface for sequence, then each type (like Either, TaskEither, Option etc) would provide some kind of method for how to implement a particular step in the sequence combinator.

I don't know how to do this yet, and also for my project I just need to unwrap Lists of Eithers at the moment. So I will be using this function in my code until this has been resolved in this project.

It's more of a suggestion at this stage, and I'm happy to take some feedback as to how to better integrate this feature into the package and work on a more comprehensive solution.

Hello,

I just started using fpdart so I have what I believe is a noob question.

I have a funcion that returns Future and I am using async/await.

Inside that function, I have an Either. In non FP y would bifurcate my paths based on the either with an if statement. To be more "FPish" I tried to use map on the Either, but what I do on both paths is async, and should be awaited before the function continues.

I tried doing
either.map((left) async => await foo(), (right) async => await bar())

which compiled, but it didn't work, as I can't await on either.map

What should be the suggested way to use option/either .map in conjunction with await?

Added Functions:

bind -> Bind other Either. asyncBind -> same as Bind, but return Future fold -> same as match (Help people who used dartz to migrate)

Wrappers:

id -> Function wrapper for return the parameter; right -> Return Right(r) left -> Return Left(l) (These wrappers also help people who used dartz to migrate).

I wrote this recently for a customer:

/// This file is used to export all the functional programming libraries used in
/// the project. It also exports the [FpState] type alias, which is used to
/// avoid conflicts with the [State] class from the Flutter SDK.
///
import 'package:fpdart/fpdart.dart' as fpdart show State;

/// The `fpdart` library is used to create functional programming constructs.
export 'package:fpdart/fpdart.dart' hide State;

/// The `tuple` library is used to create tuples, which are immutable lists of
/// fixed length.
export 'package:tuple/tuple.dart' show Tuple3, Tuple4, Tuple5, Tuple6, Tuple7;

/// A type alias for the [State] class from the `fpdart` library.
typedef FpState<S, A> = fpdart.State<S, A>;

which we then put in lib/core/functional.dart and include that instead of fpdart or tuple. It's a handy way to show how to rename the classes that conflict with other SDK or third-party packages. Maybe this could go somewhere in the docs, or in one of the examples? It'd also be a great place to add extensions to fpdart's types, so it'd need only one include for the project.

I'd have to go check the semantics of the other libraries but it would be nice to have distinctions of: try-catch for all vs for specific types

Cats has helpers for nonFatal but I'm not sure how it will work given dart lets you throw and catch everything under the sun.

One option is to follow Dart's Future with an optional test function.

// from async/future.dart
Future<T> catchError(Function onError, {bool test(Object error)?});

Another option is to specify it via type

class Test {
  static void catchOnly<T>(void Function() fn, void Function(T) onError) {
    try {
      fn();
    } on T catch(e) {
      onError(e);
    }
  }
}

main() {
  fnHandlerInt(int e) => print('Handling int: $e');
  fnHandlerError(Error e) => print('Handling Error: $e');

  print("1");
  Test.catchOnly(() => throw 1, fnHandlerInt);
  print('2');
  Test.catchOnly(() => 1 ~/ 0, fnHandlerError);
  print('3');
  Test.catchOnly(() => throw 1, fnHandlerError); // Uncaught Error
  print('4'); // unreachable
  // Output:
  // 1
  // Handling int: 1
  // 2
  // Handling Error: Unsupported operation: Result of truncating division is Infinity: 1 ~/ 0
  // 3
  // Uncaught Error: 1
}

It rarely a good idea to catch everything but the dart language doesn't offer classifications from a overflow/OOM versus a parsing error. A possible workout is to explicitly enumerate all the fatal errors and re-throw them immediately. Thoughts?

I was looking at the "List" extension, and I see this:

  /// Insert element `t` at the beginning of the [Iterable].
  Iterable<T> prepend(T t) => [t, ...this];

The return value is not an Iterable. It's a List. You could turn this function into an iterable with something like

    Iterable<T> prepend(T t) sync * { yield t; yield this* };

I just think it'd be more honest, and better for intellisense if things that are by necessity returning a List say so. After all, you can call sort() on this output, but not with an Iterable, only if it's tagged as a List.

Put another way, if we could keep Iterable to mean "might be infinite", it'd be possible to construct some very cool function applications!

Edit: Idea... you could have both an iterable extension and a list extension, properly typing the function inputs!

Edit 2: On discord, we've just demonstrated that Dart picks the most restrictive type in the case of identical signatures:

extension<T> on Iterable<T> {
  void hello() => print('Hello from Iterable extension');
}

extension<T> on List<T> {
  void hello() => print('Hello from List extension');
}

void main() {
  List<String> list = [];
  list.hello(); // Hello from List extension

  Iterable<String> iterable = list;
  iterable.hello(); // Hello from Iterable extension
}

I'm just in the middle of a major refactor which involves moving a lot of my Dartz code into FPDart. While going through your articles I found how amazing the TaskEither.tryCatch() is at cleaning up my code (😙👌) .

But now I've come to my Streams and i'm drawing a bit of a blank on how to tidy them up and wonder if this is something that FPDart has a solution for? I'm currently returning Stream<Either<AlertsFailure, List<Alert>>>> in something like this:

Stream<Either<AlertsFailure, List<Alert>>> watchAlerts() async* {
    final userOption = await _auth.getSignedInUser();
    final user = userOption.getOrElse(() => throw NotAuthenticatedError());

    final alertsRef = _firestore.allUserAlerts(user.uid.getOrCrash());
    yield* alertsRef.snapshots().map((query) {
      if (query.docs.isEmpty) {
        return const Left<AlertsFailure, List<Alert>>(AlertsFailure.noAlerts());
      }
      return Right<AlertsFailure, List<Alert>>(query.docs
          .map(
            (alert) => AlertModel.fromFirestore(alert).toDomain(),
          )
          .toList()
        ..sort((a, b) => b.dateCreated.compareTo(a.dateCreated)));
    }).onErrorReturnWith((e, stack) {
      if (e is FirebaseException && e.code.contains('permission-denied')) {
        return const Left<AlertsFailure, List<Alert>>(
            AlertsFailure.insufficientPermission());
      } else {
        return const Left<AlertsFailure, List<Alert>>(
            AlertsFailure.serverError());
      }
    });
  }

i'm trying to imagine something like TaskEither to wrap the snapshot() but don't know how to handle errors from the stream. The other idea was that there might be some kind of StreamEither but no searching has brought up any examples.

This could be my FP noobish-ness or maybe this is actually a feature request... or maybe this isn't something FP even deals with and then my Stream is the right solution?

Hello!

Thank you for your awesome package, really helped me implement most of the concepts I learned from fp-ts in Flutter.

But I do think it's missing something, and that is the Do Notation. I currently have a use case where I need to preserve values across multiple TaskEithers, and I think the Do Notation approach can solve this.

Is there going to be a Do Notation implementation soon in fpdart? Or do you have an alternative approach to my case?

Thank you!