Implementing Promise with Channels in Go

I'm trying to implement Promise in Go which would be similar to that in Javascript.

type Promise struct {
        Result chan string
        Error  chan error
}

func NewPromise() (*Promise) {
        r := make(chan string, 1)
        e := make(chan error, 1)
        return &Promise{
                Result: r,
                Error:  e,
        }
}

func main() {
        var p = NewPromise()

        go func(p *Promise) {
                time.Sleep(time.Duration(5)*time.Second)
                p.Result <- "done"
        }(p)

        if <- p.Result {
                fmt.Println(<-p.Result)
        }

        // Is it possible to do something else here while wait for 5s?

        // Once Promise is fulfilled after 5s, the Result is available.
}

How do I do the following:

1. Run a goroutine, which return Promise to the main goroutine right
   away.

2. Asynchronously do something on the main routine while wait for
   anything to be sent to either Promise.Result or Promise.Error

3. Once something is sent, return from the goroutine and make that
   channel available to be read.

A different approach without using channels, which makes it a little bit faster / more efficient:

type Promise struct {
	wg  sync.WaitGroup
	res string
	err error
}

func NewPromise(f func() (string, error)) *Promise {
	p := &Promise{}
	p.wg.Add(1)
	go func() {
		p.res, p.err = f()
		p.wg.Done()
	}()
	return p
}

func (p *Promise) Then(r func(string), e func(error)) {
	go func() {
		p.wg.Wait()
		if p.err != nil {
			e(p.err)
			return
		}
		r(p.res)
	}()
}

<kbd>playground</kbd>

There's a paper called "From Events to Futures and Promises and back" by Martin Sulzmann (published in February 2016), which covers that topic. The abstract says:

> Events based on channel communications and futures/promises are powerful but seemingly different concepts for concurrent programming. We show that one concept can be expressed in terms of the other with surprisingly little effort. Our results offer light-weight library based approaches to implement events and futures/promises. Empirical results show that our approach works well in practice.

According to the paper, futures look like this:

type Comp struct {
	value interface{}
	ok    bool
}

type Future chan Comp

func future(f func() (interface{}, bool)) Future {
	future := make(chan Comp)

	go func() {
		v, o := f()
		c := Comp{v, o}
		for {
			future <- c
		}
	}()

	return future
}

Whereas promises are implemented as follows:

type Promise struct {
	lock chan int
	ft   Future
	full bool
}

func promise() Promise {
	return Promise{make(chan int, 1), make(chan Comp), false}
}

func (pr Promise) future() Future {
	return pr.ft
}

Read up the paper for details, combinators and more.

I am also trying to implement javascript's promise :). It's a learning purpose project. In this implementation, I learn go's channel, select, goroutine. I think this small library meets your need.

p := New(func(resolve func(interface{}), reject func(error)) {
    resolve("sonla")
})

p.Then(func(data interface{}) interface{} {
    fmt.Printf("What I get is %v\n", data.(string))
    return nil
})

Await(p)

Welcome for contribution, if anyone has a better idea to implement promise in golang. Here is my repo

There are a ton of ways to do this, but what I've done for example is adjusted NewPromise() to take a function as an arg that will accept the result and error channels. Then the NewPromise method initializes a go routine with this function, returning the promise with those same channels to be read from. if you call the .Then method, this basically takes two functions as arguments. One that will handle the type that you are passing through the result channel (string) and one that handles the result type of the error channel (error). The .Then method then calls a private .then() method in a goroutine to select upon which happens first, either the result, or the error, then calls the function appropriate for each result.

For the example, I have only used a simple ticker that waits one second and then sends "hi" through the result channel.

I hope this gives you an idea of one way to do this.

GoLang Playground:
https://play.golang.org/p/xc1xvv7hRx

How about this implementation of a "promise" with just a data channel:

type Promise[A any] interface {
	Then(handler chan <- A)	
}

type promiseImpl [A any] struct {	
	value A
	done <- chan struct{}
}

func (p promiseImpl[A]) Then(handler chan <- A) {
	go func() {
		<-p.done
		handler <- p.value
	}()
}

func MakePromise[A any](resolver <- chan A) Promise[A] {
	done := make(chan struct{})
	result := promiseImpl[A]{done: done}
	go func() {
		defer close(done)
		result.value = <- resolver
	}()
	return result
}

The basic implementation idea is to exploit the fact that reading from a closed channel will never block.

So for each Then call we start a goroutine. If the promise is already resolved, it reads from a closed channel and immediately dispatches the resolved value to the handler channel. Else it will wait until the promise gets resolved.

The resolution process is another goroutine that waits for the resolved value to become available on a source channel, it then memoizes the values and closes the trigger channel, which will cause all waiting goroutines to run.

Note that no other synchronization primitives are required.