How to work with async* functions in Dart

Question

I am using flutter_bloc library.

In the bloc, the mapEventToState method is an async* function which returns Stream<BlocState>. From this function I am calling other async* functions like this yield* _handleEvent(event)

In such method, I am calling some Future returns functions but in the Future then() function it wont let me call other yield* functions.

Here is an example:

Stream<BlocState> mapEventToState(BlocEvent event) async*{
     yield* _handlesEvent(event); //This calls to worker method 
}

Stream<BlocState> _handleEvent(BlocEvent event) async* {
   _repository.getData(event.id).then((response) async* { //Calling Future returned function
         yield* _processResult(response); //This won't work
     }).catchError((e)  async* {
         yield* _handleError(e);  //This won't work either
     });

   Response response = await _repository.getData(event.id); //This do works but I want to use it like above, is it possible?
   yield* _processResult(response); //This do works
}

The question is however, how to combine between Future and Stream in dart. I could use await _repository.getData which works. but then I won't catch the error.

use simple await instead of then: var response = await _repository.getData(event.id); yield* _processResult(response); — pskink
– pskink, Commented Jun 4, 2020 at 15:46
Thanks, I've mentioned this in my question, how do I catch the error like this? I wanted to use the built in catch error of the Future api. — Moti Bartov
– Moti Bartov, Commented Jun 4, 2020 at 17:47

jamesdlin · Accepted Answer · 2020-06-04 19:03:53Z

1

await is just syntactic sugar for .then(), and putting await in a try-catch block is syntactic sugar for using .catchError. Things that you can do one way can be done with the other.
In your first version that uses .then()/.catchError(), your function doesn't return anything.
Your callbacks won't work because you're using yield* in them, but you haven't specified the callbacks with sync* or async*. To avoid name collisions, the yield keyword requires them (in the same way that await requires a function use async or async*).

Here's a version that should work with .then() and .catchError():

Stream<BlocState> _handleEvent(BlocEvent event) async* {
  yield* await _repository.getData(event.id).then((response) async* {
    yield* _processResult(response);
  }).catchError((e) async* {
    yield* _handleError(e);
  });
}

Note that the callbacks don't need to use yield*; they could just return their Streams directly:

Stream<BlocState> _handleEvent(BlocEvent event) async* {
  yield* await _repository.getData(event.id).then((response) {
    return _processResult(response);
  }).catchError((e) {
    return _handleError(e);
  });
}

But (as everyone else has noted) using await instead of the Future API simplifies the whole thing (especially since we're already using await anyway):

Stream<BlocState> _handleEvent(BlocEvent event) async* {
  try 
    response = await _repository.getData(event.id);
    yield* _processResult(response);
  } catch (e) {
    yield* _handleError(e);
  }
}

See https://dartpad.dartlang.org/fc1ff92e461754bdb35b998e7fbb3406 for a runnable example.

edited Jun 4, 2020 at 19:03

answered Jun 4, 2020 at 16:20

jamesdlin

91.1k14 gold badges185 silver badges224 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Moti Bartov Over a year ago

Thanks, of course, the _processResult and _handleError are generators which eventually yields the final State to the steam. yield won't work in the callbacks either as they are closures.

jamesdlin Over a year ago

@MotiBartov I don't understand what you mean by "yield won't work in the callbacks either as they are closures". I'm saying you need to change (response) { yield* ... } to (response) async* { yield* ... }.

Moti Bartov Over a year ago

I've tried this, it won't work. The (respose){} is actually an internal object no? The scope of it doesn't allow to yield* or yield to the stream of the outer class function

jamesdlin Over a year ago

(response) { ... } constructs an anonymous function. You absolutely can add async, async*, sync* to anonymous functions.

Moti Bartov Over a year ago

Generally you're correct, but remember that these outer function returns Stream<BlocState>, the anonymous function return type not defined so even I'd I set it async* its not the same stream. When I tried this it didn't worked.

Christopher Moore · Accepted Answer · 2020-06-04 15:18:35Z

1

Try using a try-catch block instead. It works for me with await operations.

edited Jun 4, 2020 at 15:18

Christopher Moore

17.3k11 gold badges52 silver badges63 bronze badges

answered Jun 4, 2020 at 15:17

Candace

817 bronze badges

2 Comments

Moti Bartov Over a year ago

Thanks, I thought about this but the Future api already has catch error api, I just wondered if I can use it. It's like wrapping try-catch with another try-catch

jamesdlin Over a year ago

@MotiBartov It's not wrapping anything. The Dart compiler will automatically convert try { await future; } catch { ... } to an appropriate future.then().catchError() construct. It's syntactic sugar.

Łukasz Olszewski · Accepted Answer · 2020-06-04 18:37:44Z

0

To handle errors in an async function, use try-catch:

try {
  Response response = await _repository.getData(event.id)
} catch (err) {
  print('Caught error: $err');
}

answered Jun 4, 2020 at 18:37

Łukasz Olszewski

9356 silver badges8 bronze badges

Collectives™ on Stack Overflow

How to work with async* functions in Dart

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related