Add OnceFuncReflect alongside Once{Func,Value,Values}

Author: adg

once.go

@@ -1,44 +1,70 @@
 package sync
 
-import "sync"
+import (
+	"fmt"
+	"reflect"
+	"sync"
+)
 
-// OnceFunc returns a function that invokes fn only once and returns the values
-// returned by fn. The returned function may be called concurrently.
-func OnceFunc[T any](fn func() (T, error)) func() (T, error) {
+// OnceFunc returns a function that invokes fn only once.
+// The returned function may be called concurrently.
+func OnceFunc(fn func()) func() {
+	var once sync.Once
+	return func() {
+		once.Do(fn)
+	}
+}
+
+// OnceValue returns a function that invokes fn only once and returns the
+// value returned by fn. The returned function may be called concurrently.
+func OnceValue[T any](fn func() T) func() T {
 	var (
-		once  sync.Once
-		value T
-		err   error
+		once sync.Once
+		v    T
 	)
-	return func() (T, error) {
+	return func() T {
 		once.Do(func() {
-			value, err = fn()
+			v = fn()
 		})
-		return value, err
+		return v
 	}
 }
 
-type OnceValue[T any] struct {
-	once sync.Once
-	v    T
-}
-
-func (o *OnceValue[T]) Do(fn func() T) T {
-	o.once.Do(func() {
-		o.v = fn()
-	})
-	return o.v
-}
-
-type OnceValueErr[T any] struct {
-	once sync.Once
-	v    T
-	err  error
+// OnceValues returns a function that invokes fn only once and returns the
+// values returned by fn. The returned function may be called concurrently.
+func OnceValues[T1, T2 any](fn func() (T1, T2)) func() (T1, T2) {
+	var (
+		once sync.Once
+		v1   T1
+		v2   T2
+	)
+	return func() (T1, T2) {
+		once.Do(func() {
+			v1, v2 = fn()
+		})
+		return v1, v2
+	}
 }
 
-func (o *OnceValueErr[T]) Do(fn func() (T, error)) (T, error) {
-	o.once.Do(func() {
-		o.v, o.err = fn()
-	})
-	return o.v, o.err
+// OnceFuncReflect returns a function that invokes fn only once and returns the
+// value returned by fn. The returned function may be called concurrently.
+func OnceFuncReflect[F any](fn F) F {
+	fnv := reflect.ValueOf(fn)
+	if fnv.Kind() != reflect.Func {
+		panic(fmt.Errorf("sync: OnceFuncReflect called with non-function value (%T)", fn))
+	}
+	fnt := fnv.Type()
+	if fnt.NumIn() != 0 {
+		panic(fmt.Errorf("sync: OnceFuncReflect called with function with more than zero args (%T)", fn))
+	}
+	var (
+		once    sync.Once
+		results []reflect.Value
+	)
+	return reflect.MakeFunc(fnt, func([]reflect.Value) []reflect.Value {
+		once.Do(func() {
+			results = fnv.Call(nil)
+		})
+		return results
+	}).Interface().(F)
 }

once_test.go

@@ -0,0 +1,93 @@
+package sync
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+var oops = errors.New("oops")
+
+func TestOnceFuncReflect(t *testing.T) {
+	var calls int
+	check := func() {
+		if calls > 0 {
+			panic("function called more than once")
+		}
+		calls++
+	}
+	for _, c := range []struct {
+		f    any
+		want []any
+	}{
+		{func() { check() }, nil},
+		{func() int { check(); return 42 }, []any{42}},
+		{func() (int, error) { check(); return 42, oops }, []any{42, oops}},
+	} {
+		t.Run(reflect.TypeOf(c.f).String(), func(t *testing.T) {
+			calls = 0
+			fn := OnceFuncReflect(c.f)
+			for j := 0; j < 2; j++ {
+				got := reflect.ValueOf(fn).Call(nil)
+				if len(got) != len(c.want) {
+					t.Fatalf("got %d results, want %d", len(got), len(c.want))
+				}
+				for i, v := range got {
+					if g, w := v.Interface(), c.want[i]; g != w {
+						t.Fatalf("result %d is %v, want %v", i, g, w)
+					}
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkOnceFunc(b *testing.B) {
+	b.Run("Func", func(b *testing.B) {
+		fn := OnceFunc(func() {})
+		for i := 0; i < b.N; i++ {
+			fn()
+		}
+	})
+	b.Run("Value", func(b *testing.B) {
+		fn := OnceValue(func() int { return 42 })
+		for i := 0; i < b.N; i++ {
+			if v := fn(); v != 42 {
+				b.Fatalf("got %v, want 42", v)
+			}
+		}
+	})
+	b.Run("Values", func(b *testing.B) {
+		fn := OnceValues(func() (int, error) { return 42, oops })
+		for i := 0; i < b.N; i++ {
+			if v, err := fn(); v != 42 || err != oops {
+				b.Fatalf("got %v, %v, want 42, oops", v, err)
+			}
+		}
+	})
+}
+
+func BenchmarkOnceFuncReflect(b *testing.B) {
+	b.Run("Func", func(b *testing.B) {
+		fn := OnceFuncReflect(func() {})
+		for i := 0; i < b.N; i++ {
+			fn()
+		}
+	})
+	b.Run("Value", func(b *testing.B) {
+		fn := OnceFuncReflect(func() int { return 42 })
+		for i := 0; i < b.N; i++ {
+			if v := fn(); v != 42 {
+				b.Fatalf("got %v, want 42", v)
+			}
+		}
+	})
+	b.Run("Values", func(b *testing.B) {
+		fn := OnceFuncReflect(func() (int, error) { return 42, oops })
+		for i := 0; i < b.N; i++ {
+			if v, err := fn(); v != 42 || err != oops {
+				b.Fatalf("got %v, %v, want 42, oops", v, err)
+			}
+		}
+	})
+}