Explain Futures and Streams in Dart like I'm Five

By Dart documentation:

A Future represents a computation that doesn’t complete immediately. Where a normal function returns the result, an asynchronous function returns a Future, which will eventually contain the result. The future will tell you when the result is ready.

and

A stream is a sequence of asynchronous events. It is like an asynchronous Iterable where, instead of getting the next event when you ask for it, the stream tells you that there is an event when it is ready.

I find that sometimes real-world analogies work well for explaining / remembering concepts. Here's one - it's not perfect but it helps me.

Think that you are at one of those modern sushi restaurants where you have a belt going around the room with sushi boats on it. You just sit down and wait till one goes by, grab it and eat. But they also allow you to order carry out.

• A Future is like the token with a number on it that they give you when you order takeout; you made the request, but the result is not yet ready but you have a placeholder. And when the result is ready, you get a callback (the digital board above the takeout counter shows your number or they shout it out) - you can now go in and grab your food (the result) to take out.

• A Stream is like that belt carrying little sushi bowls. By sitting down at that table, you've "subscribed" to the stream. You don't know when the next sushi boat will arrive - but when the chef (message source) places it in the stream (belt), then the subscribers will receive it. The important thing to note is that they arrive asynchronously (you have no idea when the next boat/message will come) but they will arrive in sequence (i.e., if the chef puts three types of sushi on the belt, in some order -- you will see them come by you in that same order)

From a coding perspective -- both Futures and Streams help you deal with asynchrony (where things don't happen instantly, and you don't know when you will get a result after you make a request).

The difference is that Futures are about one-shot request/response (I ask, there is a delay, I get a notification that my Future is ready to collect, and I'm done!) whereas Streams are a continuous series of responses to a single request (I ask, there is a delay, then I keep getting responses until the stream dries up or I decide to close it and walk away).

Hope that helps.

This may have already been answered pretty well, and I'm not sure a 5 year old will get this, but I'd like to have a go with some code snippets.

So...

Futures are to Dart, what Promises are to JavaScript.

In other words, I give you my word that when the time is right, I will provide the full result.

In JavaScript, we would have something along the lines of:

const asyncRequest = () => new Promise(function(resolve, reject) {

  setTimeout(function() {
    resolve("Completed");
  }, 1000);

});

asyncRequest().then((result) => console.log(result));

And in Dart:

import 'dart:async';

asyncRequest() {
  var completer = new Completer();

  new Timer(new Duration(seconds: 1), () {
    completer.complete("Completed");
  });

  return completer.future;
}

void main() {
    asyncRequest().then((result) => print(result));
}

With streams however:

Streams are to Dart, what Events are to JavaScript.

For example, typing on the keyboard creates a stream/sequence of keypresses, which are processed using events

In JavaScript, we would have something along the lines of:

document.querySelector('#input')
    .addEventListener('keypress', (e) => console.log('Value changed.'));

And in Dart:

import 'dart:html';

void main() {
    querySelector('#input')
        .addEventListener('keypress', (e) => print("Value changed"));
}

with another whereby each letter is streamed as a sequence of single characters.

import 'dart:async';

void main() {
  List<String> alphabets = 'abcdefghijklmnopqrstuvwxyz'.split('');
  var stream = new Stream.fromIterable(alphabets);

  stream.listen((data) => print(data));
}

Hope this enlightens somehow.

TL/DR:

Futures are like Promises. In fact, when Dart compiles into JavaScript, Futures are replaced with Promises.

Streams are essentially a subscription event handler.

In AngularDart, I'll use a Stream in a component like this:

  @Output()
  Stream<bool> get onButtonClose => _onButtonClose.stream;
  final StreamController<bool> _onButtonClose = new StreamController<bool>.broadcast();

And in the component's element I'll wrap an attribute of the same name as the variable tagged with the @Output annotation in parentheses:

<component (onButtonClose)="closeUI($event)"></component>

This means when the Stream has an event, it will trigger the closeUI() function and pass the event object as a parameter. Note: The Stream is set to pass objects of type bool (Stream<bool>), so the closeUI function must accept bool as a parameter.

That's the basics, but not for a five year old.

So let me go simpler:

A Future is something you can hold onto until the thing you actually want is available.

A Stream is a subscription, whenever something of interest is available, it will be passed through the Stream.

I type
asyncRequest().then((result) => print(result));
and it works.

If I want to use result outside this line how to proceed?
I've tried this, but it didn't work:

String x;
asyncRequest().then((result) => x=result);
print (x);

It shows x=null;

All in all, all the comments have given me different perspectives and clarified what was unclear about the concepts. I'm sure this will benefit someone else in future. Cheers guys

Thanks :)