once

README

hsson/once

A re-implementation and drop-in replacement of the standard sync.Once, with added support for return values! This package exports three additional Once-like primitives, in addition to the standard once.Once:

once.Error returns an error value

Do(f func() error) error

once.Value returns a value

Do(f func() interface{}) interface{}

once.ValueError returns a (value, error) tuple

Do(f func() (interface{}, error)) (interface{}, error)

These three primitives have the behavior that, like with the standard Once, the function passed is ever only executed once. However, they also return the value returned by that one execution to all subsequent callers.

Documentation

Index

• type Error
  • func (o *Error) Do(f func() error) error
• type Once
  • func (o *Once) Do(f func())
• type Value
  • func (o *Value) Do(f func() interface{}) interface{}
• type ValueError
  • func (o *ValueError) Do(f func() (interface{}, error)) (interface{}, error)

Types

type Error

type Error struct {
	// contains filtered or unexported fields
}

Error is similar to Once, except it returns an error value.

func (*Error) Do

func (o *Error) Do(f func() error) error

Do runs the specified function only once, but all callers gets the same result from that single execution.

type Once

type Once struct {
	// contains filtered or unexported fields
}

Once is backwards compatible re-implementation of sync.Once. See https://golang.org/pkg/sync/#Once

func (*Once) Do

func (o *Once) Do(f func())

Do is a backwards compatible re-implementation of Do from sync.Once

type Value

type Value struct {
	// contains filtered or unexported fields
}

Value is similar to Once, except it returns a value.

func (*Value) Do

func (o *Value) Do(f func() interface{}) interface{}

Do runs the specified function only once, but all callers gets the same result from that single execution.

type ValueError

type ValueError struct {
	// contains filtered or unexported fields
}

ValueError is similar to Once, except it return a (value, error) tuple

func (*ValueError) Do

func (o *ValueError) Do(f func() (interface{}, error)) (interface{}, error)

Do runs the specified function only once, but all callers gets the same result from that single execution.