future

README

Future

A Future is a basic primitive for managing future results of any type. The result can be set once but retrieved multiple times.

Example

package main

import (
	"fmt"
	"github.com/gavraz/async/future"
	"time"
)

func makePromise() *future.Future[int] {
	p := future.NewPromise[int]()

	go func() {
		time.Sleep(2 * time.Second)
		p.Set(42)
	}()

	return p.Future()
}

func main() {
	f := makePromise()

	go func() {
		select {
		// ...
		case <-f.Done():
		}
		fmt.Println("Done waiting for result")
	}()

	fmt.Println("Result:", f.Value())

	// output:
	// Done waiting for result
	// Result: 42
}

Documentation

Index

• type Future
  • func (f *Future[T]) Done() <-chan struct{}
  • func (f *Future[T]) Value() T
• type Promise
  • func NewPromise[T any]() *Promise[T]
  • func (p *Promise[T]) Future() *Future[T]
  • func (p *Promise[T]) Set(result T)

Types

type Future

type Future[T any] struct {
	// contains filtered or unexported fields
}

Future is used to wait for a value that may be available in the future. Callers may use Done to wait in a select statement.

func (*Future[T]) Done

func (f *Future[T]) Done() <-chan struct{}

Done is a channel used in select statements to wait until the value is available.

func (*Future[T]) Value

func (f *Future[T]) Value() T

Value blocks until the value is set and then returns it. If the result is already set, it returns immediately.

type Promise

type Promise[T any] struct {
	// contains filtered or unexported fields
}

Promise is used to commit for value. The promised value can be set using Set and be retrieved using Future.

func NewPromise

func NewPromise[T any]() *Promise[T]

func (*Promise[T]) Future

func (p *Promise[T]) Future() *Future[T]

func (*Promise[T]) Set

func (p *Promise[T]) Set(result T)

Set assigns a value to the future and makes it available to waiting routines. The result can be set only once.