prosumer

Documentation

Index

• func LiftTry[S, T any](m Try[S, T]) machine.Machine[S, T, machine.Void]
• type Base
  • func NewBase() Base
  • func (m *Base) Continue()
  • func (m *Base) Defer()
  • func (m *Base) DontWait()
  • func (m *Base) GoTo() machine.GoTo
  • func (m *Base) Return() (machine.Void, error)
• type Catch
• type Cleandown
• type Cleanup
• type Default
• type Dual
• type Naive
• type NearDual
• type NearRetry
• type Opt
• type Rethrow
• type Retry
• type Throw
• type Try

Functions

func LiftTry

func LiftTry[S, T any](m Try[S, T]) machine.Machine[S, T, machine.Void]

Types

type Base

type Base struct {
	BaseGoTo machine.GoTo
}

func NewBase

func NewBase() Base

func (*Base) Continue

func (m *Base) Continue()

func (*Base) Defer

func (m *Base) Defer()

func (*Base) DontWait

func (m *Base) DontWait()

func (*Base) GoTo

func (m *Base) GoTo() machine.GoTo

func (*Base) Return

func (m *Base) Return() (machine.Void, error)

type Catch

type Catch[T any] interface {
	machine.Await[error]
	machine.Yield[T]
	Default
}

type Cleandown

type Cleandown[T any] interface {
	machine.AwaitTry[T]
	machine.Yield[error]
	Default
}

type Cleanup

type Cleanup[S, T any] interface {
	machine.AwaitTry[S]
	machine.Yield[T]
	Default
}

type Default

type Default interface {
	machine.ReturnTry[machine.Void]
	machine.Default
}

type Dual

type Dual[S, T any] interface {
	machine.AwaitTry[S]
	machine.YieldTry[T]
	Default
}

type Naive

type Naive[S, T any] interface {
	machine.Await[S]
	machine.Yield[T]
	Default
}

type NearDual

type NearDual[S, T any] interface {
	machine.AwaitTry[S]
	machine.YieldOpt[T]
	Default
}

type NearRetry

type NearRetry[S, T any] interface {
	machine.Await[error]
	machine.YieldOpt[T]
	Default
}

type Opt

type Opt[S, T any] interface {
	machine.Await[S]
	machine.YieldOpt[T]
	Default
}

type Rethrow

type Rethrow interface {
	machine.Await[error]
	machine.Yield[error]
	Default
}

type Retry

type Retry[S, T any] interface {
	machine.Await[error]
	machine.YieldTry[T]
	Default
}

type Throw

type Throw[S any] interface {
	machine.Await[S]
	machine.Yield[error]
	Default
}

type Try

type Try[S, T any] interface {
	machine.Await[S]
	machine.YieldTry[T]
	Default
}