compute

type ByteStreamWriter ¶

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

func NewByteStream(ctx context.Context) (*ByteStreamWriter, error)

func (bsw *ByteStreamWriter) Close() error

func (bsw *ByteStreamWriter) Complete() (bytestream.ByteStream, error)

func (bsw *ByteStreamWriter) Write(p []byte) (int, error)

type Cacheable ¶

type Cacheable[V any] interface {
	Digester
	LoadCached(context.Context, cache.Cache, CacheableInstance, schema.Digest) (Result[V], error)
	Cache(context.Context, cache.Cache, V) (schema.Digest, error)
}

type CacheableInstance ¶

type CacheableInstance interface {
	NewInstance() interface{}
}

type Computable ¶

type Computable[V any] interface {
	Action() *tasks.ActionEvent
	Inputs() *In
	Output() Output // Optional.
	Compute(context.Context, Resolved) (V, error)

	UntypedComputable
}

A computable represents a node in a computation graph. Each computation node produces a value, which is computed by its `Compute` method. A node's output can be cached, and is keyed by all declared inputs. For correctness, it is required that all meaningful inputs that may impact the semantics of the output (and its digest), be listed in `Inputs`. A node can also depend on other nodes, and use their computed values. That relationship is established by declaring another Computable as an Input to this one. The resulting value, will then be available in `Resolved`. If any of node's dependencies fails to compute, the node implicitly fails as well (with the same error).

func Collect[V any](ev *tasks.ActionEvent, computables ...Computable[V]) Computable[[]ResultWithTimestamp[V]]

func Consume[V any](action *tasks.ActionEvent, from Computable[V], compute func(context.Context, ResultWithTimestamp[V]) error) Computable[V]

func Error[V any](err error) Computable[V]

func Inline[To any](action *tasks.ActionEvent, compute func(context.Context) (To, error)) Computable[To]

func Map[V any](action *tasks.ActionEvent, inputs *In, output Output,
	compute func(context.Context, Resolved) (V, error)) Computable[V]

func Merge[V any](desc string, c Computable[[]ResultWithTimestamp[[]V]]) Computable[[]V]

func Named[V any](action *tasks.ActionEvent, c Computable[V]) Computable[V]

func Precomputed[V any](v V, computeDigest func(context.Context, V) (schema.Digest, error)) Computable[V]

func Sticky[V any](action *tasks.ActionEvent, c Computable[V]) Computable[V]

func Transform[From, To any](desc string, from Computable[From], compute func(context.Context, From) (To, error)) Computable[To]

type ComputeDigestFunc ¶

type ComputeDigestFunc func(context.Context, any) (schema.Digest, error)

type Detach ¶

type Detach struct {
	Action *tasks.ActionEvent
	Do     func(context.Context) error
}

type DigestFunc ¶

type DigestFunc func(context.Context) (schema.Digest, error)

func (f DigestFunc) ComputeDigest(ctx context.Context) (schema.Digest, error)

type Digester ¶

type Digester interface {
	ComputeDigest(context.Context, any) (schema.Digest, error)
}

type Digestible ¶

type Digestible interface {
	ComputeDigest(context.Context) (schema.Digest, error)
}

type DoScoped ¶

type DoScoped[V any] struct{}

A Computable whose lifecycle is bound to the surrounding Do() invocation. If the Computable is attempted to be computed outside a Do()-bound context, the program panics. A Do()-scoped Computable _must_ have deterministic inputs, so that a key can be calculated. This type of Computable is useful when different parts of the program want to share a computation that depends strictly on the inputs.

func (c DoScoped[V]) Output() Output

type Future ¶

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

func (f *Future[V]) Wait(ctx context.Context) (ResultWithTimestamp[V], error)

type In ¶

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

func Inputs() *In

func (in *In) Bool(key string, v bool) *In

func (in *In) Computable(key string, c UntypedComputable) *In

func (in *In) Digest(key string, d Digestible) *In

func (in *In) Indigestible(key string, value interface{}) *In

func (in *In) JSON(key string, json interface{}) *In

func (in *In) Marshal(key string, marshaller func(context.Context, io.Writer) error) *In

func (in *In) NonCacheable() *In

func (in *In) Proto(key string, msg proto.Message) *In

func (in *In) Str(key string, str string) *In

func (in *In) StrMap(key string, m map[string]string) *In

func (in *In) Stringer(key string, str fmt.Stringer) *In

func (in *In) Strs(key string, strs []string) *In

type LocalScoped ¶

type LocalScoped[V any] struct {
	// contains filtered or unexported fields
}

A Computable whose lifecycle is bound to the environment where it is computed. This is the most common option, as it yields for the clearest cancellation semantics and instance-level sharing as expected in Go. A "LocalScoped" Computable embeds a Promise which keeps track of the computation state of the Computable.

func (c *LocalScoped[V]) Output() Output

type ObserveNote ¶ added in v0.0.109

type ObserveNote string

const (
	ObserveContinuing ObserveNote = "observe.continuing"
	ObserveDone       ObserveNote = "observe.done"
)

type Orch ¶

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

func On(ctx context.Context) *Orch

func (g *Orch) BestEffort(ev *tasks.ActionEvent, do func(context.Context) error)

func (g *Orch) Call(callback func(context.Context) error) error

func (g *Orch) Cleanup(ev *tasks.ActionEvent, f func(context.Context) error)

func (g *Orch) Detach(ev *tasks.ActionEvent, f func(context.Context) error)

func (g *Orch) DetachWith(d Detach)

type Output ¶

type Output struct {
	NonDeterministic bool
	NotCacheable     bool
}

func (o Output) CanCache() bool

func (o Output) DontCache() Output

type PrecomputeScoped ¶

type PrecomputeScoped[V any] struct{}

This Computable embeds a "precomputed" value and Compute() is guaranteed to return immediately.

func (c PrecomputeScoped[V]) Output() Output

type Promise ¶

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

func ErrPromise[V any](err error) *Promise[V]

func NewPromise[V any](g *Orch, action *tasks.ActionEvent, callback func(context.Context) (ResultWithTimestamp[V], error)) *Promise[V]

func (f *Promise[V]) Future() *Future[V]

type Resolved ¶

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

type Result ¶

type Result[V any] struct {
	Digest           schema.Digest
	NonDeterministic bool
	Value            V
}

func NoResult[V any]() (Result[V], error)

func (r Result[V]) HasDigest() bool

type ResultWithTimestamp ¶

type ResultWithTimestamp[V any] struct {
	Result[V]
	Set       bool
	Cached    bool
	ActionID  tasks.ActionID
	Started   time.Time
	Completed time.Time // When this value was computed (if known).
	// contains filtered or unexported fields
}

func Get[V any](ctx context.Context, c Computable[V]) (ResultWithTimestamp[V], error)

func GetDep[V any](deps Resolved, c Computable[V], key string) (ResultWithTimestamp[V], bool)

func GetDepWithType[V any](deps Resolved, key string) (ResultWithTimestamp[V], bool)

type Sinkable ¶

type Sinkable interface {
	Inputs() *In
	Updated(context.Context, Resolved) error
	Cleanup(context.Context) error
}

type TransformErrorFunc ¶

type TransformErrorFunc func(error) error

type UntypedComputable ¶ added in v0.0.109

type UntypedComputable interface {
	Action() *tasks.ActionEvent
	Inputs() *In
	Output() Output // Optional.
	// contains filtered or unexported methods
}

type Versioned ¶

type Versioned interface {
	Observe(context.Context, func(ResultWithTimestamp[any], ObserveNote)) (func(), error)
}