Futures in erlang

future.erl

-module(future).

-export([async/1, fulfill/2, block/1, test/0]).

async(Fun) ->
    F = mk(),
    spawn(fun() -> 
                   fulfill(F, Fun()) end),
    F.

fulfill(F, Val) ->
    F ! {fulfill, Val},
    ok.

block(F) ->
    R = make_ref(),
    F ! {get, self(), R},
    receive
        {reply, Val, R} ->
            exit(F, kill),
            Val
    end.

await(Waiting) ->
    receive
        {fulfill, Val} ->
            [notify(W, Val, Ref) || {get, W, Ref} <- Waiting],
            serve(Val);
        {get, W, Ref} ->
            await([{get, W, Ref} | Waiting])
    end.


notify(W, Val, Ref) ->
    W ! {reply, Val, Ref},
    ok.

serve(Val) ->
    receive
        {get, W, Ref} ->
            notify(W, Val, Ref),
            serve(Val)
    end.

mk() ->
    spawn(fun() -> await([]) end).

test() ->
    F = async(fun() ->
                      io:format("working hard...~n"),
                      receive after 2000 -> ok end,
                      io:format("got it!~n"),
                      10
              end),
    spawn(fun() ->
                  io:format("waiting..~n"),
                  io:format("received result: ~w~n", [block(F)]),
                  io:format("received result: ~w~n", [block(F)])
          end),
    ok.