Future–Promise Pattern #

// ANTI-PATTERN: sequential execution — all operations wait for each other
func fetchUserData(userID int) UserData {
    profile := fetchProfile(userID)      // 300ms
    orders  := fetchOrders(userID)       // 400ms
    reviews := fetchReviews(userID)      // 200ms
    // Total wait time: 900ms
    return merge(profile, orders, reviews)
}

// CORRECT: run all three in parallel with Futures
func fetchUserData(userID int) UserData {
    fProfile := NewFuture(func() Profile { return fetchProfile(userID) })
    fOrders  := NewFuture(func() []Order { return fetchOrders(userID) })
    fReviews := NewFuture(func() []Review { return fetchReviews(userID) })
    // All three tasks run in parallel — total wait: ~400ms (the slowest task)
    return merge(fProfile.Get(), fOrders.Get(), fReviews.Get())
}

package main

import (
	"fmt"
	"time"
)

// Future is a placeholder for a value that will be available later
type Future struct {
	result chan int
}

// NewFuture acts as a Promise — runs the task in the background
// and returns a Future that can be queried later
func NewFuture(task func() int) *Future {
	f := &Future{
		result: make(chan int, 1), // CORRECT: buffered so the goroutine does not leak
	}
	go func() {
		f.result <- task() // task runs in a separate goroutine
	}()
	return f // returned immediately, the task is still running in the background
}

// Get blocks until the value is available, then returns it
func (f *Future) Get() int {
	return <-f.result
}

func main() {
	// Future created — the task starts immediately in the background
	future := NewFuture(func() int {
		fmt.Println("[Task] Starting heavy computation...")
		time.Sleep(2 * time.Second)
		return 42
	})

	// We can do other things while the task runs
	fmt.Println("[Main] Task is running in the background")
	fmt.Println("[Main] Doing other work...")
	time.Sleep(500 * time.Millisecond)
	fmt.Println("[Main] Other work done, now getting the future result")

	// Blocking only happens here, and only if the task is not done yet
	result := future.Get()
	fmt.Printf("[Main] Result received: %d\n", result)
}

package main

import (
	"errors"
	"fmt"
	"time"
)

// Result wraps a value and an error in one struct
type Result[T any] struct {
	Value T
	Err   error
}

// Future[T] is a type-safe Future for type T
type Future[T any] struct {
	result chan Result[T]
}

// NewFuture runs the task in the background and returns a Future
func NewFuture[T any](task func() (T, error)) *Future[T] {
	f := &Future[T]{
		result: make(chan Result[T], 1), // CORRECT: buffered
	}
	go func() {
		val, err := task()
		f.result <- Result[T]{Value: val, Err: err}
	}()
	return f
}

// Get blocks until the result is available and returns (value, error)
func (f *Future[T]) Get() (T, error) {
	res := <-f.result
	return res.Value, res.Err
}

// fetchUser simulates a database fetch
func fetchUser(id int) (string, error) {
	time.Sleep(300 * time.Millisecond)
	if id <= 0 {
		return "", errors.New("invalid user ID")
	}
	return fmt.Sprintf("User-%d", id), nil
}

func main() {
	fUser := NewFuture(func() (string, error) {
		return fetchUser(7)
	})

	fInvalid := NewFuture(func() (string, error) {
		return fetchUser(-1) // this one will fail
	})

	// Both futures run in parallel
	user, err := fUser.Get()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("User:", user)
	}

	_, err = fInvalid.Get()
	if err != nil {
		fmt.Println("Error (expected):", err)
	}
}

package main

import (
	"fmt"
	"time"
)

type Future[T any] struct {
	result chan T
}

func NewFuture[T any](task func() T) *Future[T] {
	f := &Future[T]{result: make(chan T, 1)}
	go func() { f.result <- task() }()
	return f
}

func (f *Future[T]) Get() T { return <-f.result }

// simulated HTTP request to a different endpoint
func fetchEndpoint(name string, delay time.Duration) string {
	time.Sleep(delay)
	return fmt.Sprintf("response from %s", name)
}

func main() {
	start := time.Now()

	// Fan-out: all requests run in parallel
	futures := []*Future[string]{
		NewFuture(func() string { return fetchEndpoint("service-A", 400*time.Millisecond) }),
		NewFuture(func() string { return fetchEndpoint("service-B", 250*time.Millisecond) }),
		NewFuture(func() string { return fetchEndpoint("service-C", 600*time.Millisecond) }),
		NewFuture(func() string { return fetchEndpoint("service-D", 150*time.Millisecond) }),
	}

	// Fan-in: collect all the results
	results := make([]string, len(futures))
	for i, f := range futures {
		results[i] = f.Get()
	}

	elapsed := time.Since(start)
	for _, r := range results {
		fmt.Println(r)
	}
	fmt.Printf("Total time: %v (without parallel: ~1400ms)\n", elapsed)
}

package main

import (
	"context"
	"errors"
	"fmt"
	"time"
)

type Result[T any] struct {
	Value T
	Err   error
}

type Future[T any] struct {
	result chan Result[T]
}

// NewFutureWithContext creates a Future responsive to cancellation
func NewFutureWithContext[T any](ctx context.Context, task func() (T, error)) *Future[T] {
	f := &Future[T]{result: make(chan Result[T], 1)}
	go func() {
		// Run the task in a separate goroutine so it can be cancelled
		taskResult := make(chan Result[T], 1)
		go func() {
			val, err := task()
			taskResult <- Result[T]{Value: val, Err: err}
		}()

		select {
		case res := <-taskResult:
			f.result <- res // task completed normally
		case <-ctx.Done():
			var zero T
			f.result <- Result[T]{
				Value: zero,
				Err:   errors.New("future cancelled: " + ctx.Err().Error()),
			}
		}
	}()
	return f
}

func (f *Future[T]) Get() (T, error) {
	res := <-f.result
	return res.Value, res.Err
}

func longRunningTask() (string, error) {
	time.Sleep(3 * time.Second) // simulated long task
	return "computation result", nil
}

func main() {
	// Context with a 1-second timeout — the task needs 3 seconds, so it will be cancelled
	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
	defer cancel()

	future := NewFutureWithContext(ctx, longRunningTask)

	result, err := future.Get()
	if err != nil {
		fmt.Println("Future failed:", err)
		return
	}
	fmt.Println("Result:", result)
}

package main

import (
	"fmt"
	"time"
)

type Result[T any] struct {
	Value T
	Err   error
	Index int
}

type Future[T any] struct {
	result chan Result[T]
	index  int
}

func NewFuture[T any](index int, task func() (T, error)) *Future[T] {
	f := &Future[T]{result: make(chan Result[T], 1), index: index}
	go func() {
		val, err := task()
		f.result <- Result[T]{Value: val, Err: err, Index: index}
	}()
	return f
}

// WhenAll waits for all futures to finish and collects the results
// The result order follows the order of the given futures
func WhenAll[T any](futures ...*Future[T]) []Result[T] {
	results := make([]Result[T], len(futures))
	for _, f := range futures {
		res := <-f.result
		results[res.Index] = res
	}
	return results
}

func main() {
	futures := []*Future[string]{
		NewFuture(0, func() (string, error) {
			time.Sleep(300 * time.Millisecond)
			return "data from cache", nil
		}),
		NewFuture(1, func() (string, error) {
			time.Sleep(600 * time.Millisecond)
			return "data from database", nil
		}),
		NewFuture(2, func() (string, error) {
			time.Sleep(150 * time.Millisecond)
			return "data from config", nil
		}),
	}

	results := WhenAll(futures...)
	for _, r := range results {
		if r.Err != nil {
			fmt.Printf("Future[%d] error: %v\n", r.Index, r.Err)
		} else {
			fmt.Printf("Future[%d] result: %s\n", r.Index, r.Value)
		}
	}
}

// ✗ Unbuffered channel — goroutine leak if Get() is never called
type LeakyFuture struct {
    result chan int
}
func NewLeakyFuture(task func() int) *LeakyFuture {
    f := &LeakyFuture{result: make(chan int)} // ✗ unbuffered!
    go func() {
        f.result <- task() // will block forever if Get() is not called
    }()
    return f
}

// ✓ Always use a buffered channel with capacity 1
type SafeFuture struct {
    result chan int
}
func NewSafeFuture(task func() int) *SafeFuture {
    f := &SafeFuture{result: make(chan int, 1)} // ✓ buffered
    go func() {
        f.result <- task()
    }()
    return f
}

// ✗ Get() called more than once — blocks forever on the second call
future := NewSafeFuture(func() int { return 42 })
val1 := future.Get() // ✓ succeeds
val2 := future.Get() // ✗ blocks forever — the channel is already empty

// ✓ Store the Get() result in a variable if it is needed more than once
result := future.Get() // ✓ call once
use(result)
use(result) // use the variable, not future.Get() again

// ✗ Launching too many Futures without limits
for i := 0; i < 1_000_000; i++ {
    go func() { /* future */ }() // ✗ can exhaust memory and the scheduler
}

// ✓ Limit with a semaphore or worker pool for large fan-outs
sem := make(chan struct{}, 50) // max 50 concurrent goroutines
for i := 0; i < 1_000_000; i++ {
    sem <- struct{}{}
    go func() {
        defer func() { <-sem }()
        /* future task */
    }()
}