go-promise is a Go promise and future library.

Inspired by Futures and promises

Installation

$ go get github.com/fanliao/go-promise

Features

• Future and Promise

  • NewPromise()
  • promise.Future

• Promise and Future callbacks

  • .OnSuccess(v interface{})
  • .OnFailure(v interface{})
  • .OnComplete(v interface{})
  • .OnCancel()

• Get the result of future

  • .Get()
  • .GetOrTimeout()
  • .GetChan()

• Set timeout for future

  • .SetTimeout(ms)

• Merge multiple promises

  • WhenAll(func1, func2, func3, ...)
  • WhenAny(func1, func2, func3, ...)
  • WhenAnyMatched(func1, func2, func3, ...)

• Pipe

  • .Pipe(funcWithDone, funcWithFail)

• Cancel the future

  • .Cancel()
  • .IsCancelled()

• Create future by function

  • Start(func() (r interface{}, e error))
  • Start(func())
  • Start(func(canceller Canceller) (r interface{}, e error))
  • Start(func(canceller Canceller))

• Immediate wrappers

  • Wrap(interface{})

• Chain API

  • Start(taskDone).Done(done1).Fail(fail1).Always(alwaysForDone1).Pipe(f1, f2).Done(done2)

Quick start

Promise and Future

import "github.com/fanliao/go-promise"
import "net/http"

p := promise.NewPromise()
p.OnSuccess(func(v interface{}) {
   ...
}).OnFailure(func(v interface{}) {
   ...
}).OnComplete(func(v interface{}) {
   ...
})

go func(){
	url := "http://example.com/"
	
	resp, err := http.Get(url)
	defer resp.Body.Close()
	if err != nil {
		p.Reject(err)
	}
	
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		p.Reject(err)
	}
	p.Resolve(body)
}()
r, err := p.Get()

If you want to provide a read-only view, you can get a future variable:

p.Future //cannot Resolve, Reject for a future

Can use Start function to submit a future task, it will return a future variable, so cannot Resolve or Reject the future outside of Start function:

import "github.com/fanliao/go-promise"
import "net/http"

task := func()(r interface{}, err error){
	url := "http://example.com/"
	
	resp, err := http.Get(url)
	defer resp.Body.Close()
	if err != nil {
		return nil, err
	}
	
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	return body, nil
}

f := promise.Start(task).OnSuccess(func(v interface{}) {
   ...
}).OnFailure(func(v interface{}) {
   ...
}).OnComplete(func(v interface{}) {
   ...
})
r, err := f.Get()

Get the result of future

Please note the process will be block until the future task is completed

f := promise.Start(func() (r interface{}, err error) {
	return "ok", nil  
})
r, err := f.Get()  //return "ok", nil

f := promise.Start(func() (r interface{}, err error) {
	return nil, errors.New("fail")  
})
r, err := f.Get()  //return nil, errorString{"fail"}

Can wait until timeout

f := promise.Start(func() (