jonbodner

func (f *futureImpl) Then(next Step) Interface {
    nextFuture := New(func() (interface{}, error) {
        result, err := f.Get()
        if err != nil {
            return result, err
        }
        return next(result)
    })
    return nextFuture
}

jonbodner

// Interface represents a future. No concrete implementation is
// exposed; all access to a future is via this interface.
type Interface interface {
    // Get returns the values calculated by the future. It will pause until 
    // the value is calculated.
    //
    // If Get is invoked multiple times, the same value will be returned each time.
    // Subsequent calls to Get will return instantaneously.
    Get() (interface{}, error)

jonbodner

func main() {
    a := 10
    f := future.New(func() (interface{}, error) {
        return doSomethingThatTakesAWhile(a)
    })

    // this will wait for a second to complete
    // and will return nil for both val and err
    // and timeout will be true
    val, timeout, err := f.GetUntil(1 * time.Second)

jonbodner

func (f *futureImpl) GetUntil(d time.Duration) (interface{}, bool, error) {
	select {
	case <-f.done:
		val, err := f.Get()
		return val, false, err
	case <-time.After(d):
		return nil, true, nil
	}

	// This should never be executed

jonbodner

// Interface represents a future. No concrete implementation is
// exposed; all access to a future is via this interface.
type Interface interface {
	// Get returns the values calculated by the future. It will pause until
	// the value is calculated.
	//
	// If Get is invoked multiple times, the same value will be returned each time.
	// Subsequent calls to Get will return instantaneously.
	Get() (interface{}, error)

jonbodner

// New creates a new Future that wraps the provided function.
func New(inFunc Processor) Interface {
	f := &futureImpl {
		done: make(chan struct{}),
	}
	
	go func() {
		f.val, f.err = inFunc()
		close(f.done)
	}()

jonbodner

type futureImpl struct {
	done chan struct{}
	val interface{}
	err error
}

func (f *futureImpl) Get() (interface{}, error) {
	<-f.done
	return f.val, f.err
}

jonbodner

 package main

 import (
	 "time"
	 "fmt"
	 "future"
 )

 func doSomethingThatTakesAWhile(i int) (int, error) {
 	// what this does isn’t that important for the example

jonbodner

func New(inFunc Process) Interface {
    //…
}

jonbodner

type Process func() (interface{}, error)