imbue

func Decorate0 ¶ added in v0.4.0

func Decorate0[T any](
	con ContainerAware,
	dec func(Context, T) (T, error),
	options ...DecorateOption,
)

Decorate0 describes how to decorate values of type T after construction.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type DecoratedDependency struct {
		Value string
	}

	// Declare a decorator for the DecoratedDependency type.
	imbue.Decorate0(
		con,
		func(
			ctx imbue.Context,
			d *DecoratedDependency,
		) (*DecoratedDependency, error) {
			d.Value = "<decorated value>"
			return d, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.DecoratedDependency

package main

import (
	"fmt"
	"net/http"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// This example illustrates how decoration can be used to add routes to an
	// http.ServeMux that is declared in a separate location.

	imbue.With0(
		con,
		func(
			ctx imbue.Context,
		) (*http.ServeMux, error) {
			return http.NewServeMux(), nil
		},
	)

	imbue.Decorate0(
		con,
		func(
			ctx imbue.Context,
			mux *http.ServeMux,
		) (*http.ServeMux, error) {
			mux.HandleFunc("/account", func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintf(w, "account handler")
			})

			mux.HandleFunc("/dashboard", func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintf(w, "dashboard handler")
			})

			return mux, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *http.ServeMux

func Decorate1 ¶ added in v0.4.0

func Decorate1[T, D any](
	con ContainerAware,
	dec func(Context, T, D) (T, error),
	options ...DecorateOption,
)

Decorate1 describes how to decorate values of type T after construction using a single additional dependency.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type UpstreamDependency struct{}
	type DecoratedDependency struct {
		Up *UpstreamDependency
	}

	// Declare a decorator for the DecoratedDependency type. It depends on the
	// upstream dependency type (which is assumed to be declared elsewhere).
	imbue.Decorate1(
		con,
		func(
			ctx imbue.Context,
			d *DecoratedDependency,
			up *UpstreamDependency,
		) (*DecoratedDependency, error) {
			d.Up = up
			return d, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.DecoratedDependency
    └── *imbue_test.UpstreamDependency

func Decorate2 ¶ added in v0.4.0

func Decorate2[T, D1, D2 any](
	con ContainerAware,
	dec func(Context, T, D1, D2) (T, error),
	options ...DecorateOption,
)

Decorate2 describes how to decorate values of type T after construction using 2 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type UpstreamDependency1 struct{}
	type UpstreamDependency2 struct{}
	type DecoratedDependency struct {
		Up1 *UpstreamDependency1
		Up2 *UpstreamDependency2
	}

	// Declare a decorator for the DecoratedDependency type. It depends on the
	// two upstream dependency types (which are assumed to be declared
	// elsewhere).
	imbue.Decorate2(
		con,
		func(
			ctx imbue.Context,
			d *DecoratedDependency,
			up1 *UpstreamDependency1,
			up2 *UpstreamDependency2,
		) (*DecoratedDependency, error) {
			d.Up1 = up1
			d.Up2 = up2
			return d, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.DecoratedDependency
    ├── *imbue_test.UpstreamDependency1
    └── *imbue_test.UpstreamDependency2

func Decorate3 ¶ added in v0.4.0

func Decorate3[T, D1, D2, D3 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3) (T, error),
	options ...DecorateOption,
)

Decorate3 describes how to decorate values of type T after construction using 3 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Decorate4 ¶ added in v0.4.0

func Decorate4[T, D1, D2, D3, D4 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3, D4) (T, error),
	options ...DecorateOption,
)

Decorate4 describes how to decorate values of type T after construction using 4 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Decorate5 ¶ added in v0.4.0

func Decorate5[T, D1, D2, D3, D4, D5 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3, D4, D5) (T, error),
	options ...DecorateOption,
)

Decorate5 describes how to decorate values of type T after construction using 5 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Decorate6 ¶ added in v0.4.0

func Decorate6[T, D1, D2, D3, D4, D5, D6 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3, D4, D5, D6) (T, error),
	options ...DecorateOption,
)

Decorate6 describes how to decorate values of type T after construction using 6 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Decorate7 ¶ added in v0.4.0

func Decorate7[T, D1, D2, D3, D4, D5, D6, D7 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3, D4, D5, D6, D7) (T, error),
	options ...DecorateOption,
)

Decorate7 describes how to decorate values of type T after construction using 7 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Decorate8 ¶ added in v0.4.0

func Decorate8[T, D1, D2, D3, D4, D5, D6, D7, D8 any](
	con ContainerAware,
	dec func(Context, T, D1, D2, D3, D4, D5, D6, D7, D8) (T, error),
	options ...DecorateOption,
)

Decorate8 describes how to decorate values of type T after construction using 8 additional dependencies.

The dependency being decorated is passed to dec and replaced with the decorator's return value.

The decorated dependency may be manipulated in-place.

func Go1 ¶ added in v0.6.2

func Go1[D any](
	g *WaitGroup,
	fn func(context.Context, D) error,
	options ...InvokeOption,
)

Go1 starts a new goroutine by calling a function with a single dependency.

func Go2 ¶ added in v0.6.2

func Go2[D1, D2 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2) error,
	options ...InvokeOption,
)

Go2 starts a new goroutine by calling a function with 2 dependencies.

func Go3 ¶ added in v0.6.2

func Go3[D1, D2, D3 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3) error,
	options ...InvokeOption,
)

Go3 starts a new goroutine by calling a function with 3 dependencies.

func Go4 ¶ added in v0.6.2

func Go4[D1, D2, D3, D4 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3, D4) error,
	options ...InvokeOption,
)

Go4 starts a new goroutine by calling a function with 4 dependencies.

func Go5 ¶ added in v0.6.2

func Go5[D1, D2, D3, D4, D5 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3, D4, D5) error,
	options ...InvokeOption,
)

Go5 starts a new goroutine by calling a function with 5 dependencies.

func Go6 ¶ added in v0.6.2

func Go6[D1, D2, D3, D4, D5, D6 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3, D4, D5, D6) error,
	options ...InvokeOption,
)

Go6 starts a new goroutine by calling a function with 6 dependencies.

func Go7 ¶ added in v0.6.2

func Go7[D1, D2, D3, D4, D5, D6, D7 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3, D4, D5, D6, D7) error,
	options ...InvokeOption,
)

Go7 starts a new goroutine by calling a function with 7 dependencies.

func Go8 ¶ added in v0.6.2

func Go8[D1, D2, D3, D4, D5, D6, D7, D8 any](
	g *WaitGroup,
	fn func(context.Context, D1, D2, D3, D4, D5, D6, D7, D8) error,
	options ...InvokeOption,
)

Go8 starts a new goroutine by calling a function with 8 dependencies.

func Invoke0 ¶ added in v0.6.1

func Invoke0(
	ctx context.Context,
	con *Container,
	fn func(context.Context) error,
	options ...InvokeOption,
) error

Invoke0 calls a function without dependencies.

This function does not use the container at all; it is included to aid while refactoring.

func Invoke1 ¶

func Invoke1[D any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D) error,
	options ...InvokeOption,
) error

Invoke1 calls a function with a single dependency.

package main

import (
	"context"
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type Dependency struct{ Value string }

	// Declare a constructor for the Dependency type.
	imbue.With0(
		con,
		func(ctx imbue.Context) (Dependency, error) {
			return Dependency{"<value>"}, nil
		},
	)

	// Invoke a function that depends on the two dependency types declared
	// above.
	if err := imbue.Invoke1(
		context.Background(),
		con,
		func(
			ctx context.Context,
			dep Dependency,
		) error {
			fmt.Println(dep)
			return nil
		},
	); err != nil {
		panic(err)
	}
}

Output:

{<value>}

func Invoke2 ¶

func Invoke2[D1, D2 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2) error,
	options ...InvokeOption,
) error

Invoke2 calls a function with 2 dependencies.

package main

import (
	"context"
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type Dependency1 struct{ Value string }
	type Dependency2 struct{ Value string }

	// Declare a constructor for the Dependency1 type.
	imbue.With0(
		con,
		func(ctx imbue.Context) (Dependency1, error) {
			return Dependency1{"<value-1>"}, nil
		},
	)

	// Declare a constructor for the Dependency2 type.
	imbue.With0(
		con,
		func(ctx imbue.Context) (Dependency2, error) {
			return Dependency2{"<value-2>"}, nil
		},
	)

	// Invoke a function that depends on the two dependency types declared
	// above.
	if err := imbue.Invoke2(
		context.Background(),
		con,
		func(
			ctx context.Context,
			dep1 Dependency1,
			dep2 Dependency2,
		) error {
			fmt.Println(dep1)
			fmt.Println(dep2)
			return nil
		},
	); err != nil {
		panic(err)
	}
}

Output:

{<value-1>}
{<value-2>}

func Invoke3 ¶

func Invoke3[D1, D2, D3 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3) error,
	options ...InvokeOption,
) error

Invoke3 calls a function with 3 dependencies.

func Invoke4 ¶

func Invoke4[D1, D2, D3, D4 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3, D4) error,
	options ...InvokeOption,
) error

Invoke4 calls a function with 4 dependencies.

func Invoke5 ¶

func Invoke5[D1, D2, D3, D4, D5 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3, D4, D5) error,
	options ...InvokeOption,
) error

Invoke5 calls a function with 5 dependencies.

func Invoke6 ¶

func Invoke6[D1, D2, D3, D4, D5, D6 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3, D4, D5, D6) error,
	options ...InvokeOption,
) error

Invoke6 calls a function with 6 dependencies.

func Invoke7 ¶

func Invoke7[D1, D2, D3, D4, D5, D6, D7 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3, D4, D5, D6, D7) error,
	options ...InvokeOption,
) error

Invoke7 calls a function with 7 dependencies.

func Invoke8 ¶

func Invoke8[D1, D2, D3, D4, D5, D6, D7, D8 any](
	ctx context.Context,
	con *Container,
	fn func(context.Context, D1, D2, D3, D4, D5, D6, D7, D8) error,
	options ...InvokeOption,
) error

Invoke8 calls a function with 8 dependencies.

func With0 ¶

func With0[T any](
	con ContainerAware,
	ctor func(Context) (T, error),
	options ...WithOption,
)

With0 describes how to construct values of type T.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare a type to use as a dependency within the example.
	type Dependency struct{}

	// Declare a constructor for the Dependency type.
	imbue.With0(
		con,
		func(ctx imbue.Context) (*Dependency, error) {
			return &Dependency{}, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.Dependency

func With0Grouped ¶ added in v0.3.0

func With0Grouped[G Group, T any](
	con ContainerAware,
	ctor func(Context) (T, error),
	options ...WithGroupedOption,
)

With0Grouped describes how to construct grouped values of type T.

G is the group that contains the dependency. T is the type of the dependency.

func With0Named ¶

func With0Named[N Name[T], T any](
	con ContainerAware,
	ctor func(Context) (T, error),
	options ...WithNamedOption,
)

With0Named describes how to construct named values of type T.

N is the name given to the dependency. T is the type of the dependency.

func With1 ¶

func With1[T, D any](
	con ContainerAware,
	ctor func(Context, D) (T, error),
	options ...WithOption,
)

With1 describes how to construct values of type T from a single dependency.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type UpstreamDependency struct{}
	type Dependency struct {
		Up *UpstreamDependency
	}

	// Declare a constructor for the Dependency type. It depends on the upstream
	// dependency type (which is assumed to be declared elsewhere).
	imbue.With1(
		con,
		func(
			ctx imbue.Context,
			up *UpstreamDependency,
		) (*Dependency, error) {
			return &Dependency{up}, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.Dependency
    └── *imbue_test.UpstreamDependency

func With1Grouped ¶ added in v0.3.0

func With1Grouped[G Group, T, D any](
	con ContainerAware,
	ctor func(Context, D) (T, error),
	options ...WithGroupedOption,
)

With1Grouped describes how to construct grouped values of type T from a single dependency.

G is the group that contains the dependency. T is the type of the dependency.

func With1Named ¶

func With1Named[N Name[T], T, D any](
	con ContainerAware,
	ctor func(Context, D) (T, error),
	options ...WithNamedOption,
)

With1Named describes how to construct named values of type T from a single dependency.

N is the name given to the dependency. T is the type of the dependency.

func With2 ¶

func With2[T, D1, D2 any](
	con ContainerAware,
	ctor func(Context, D1, D2) (T, error),
	options ...WithOption,
)

With2 describes how to construct values of type T from 2 dependencies.

package main

import (
	"fmt"

	"github.com/dogmatiq/imbue"
)

func main() {
	con := imbue.New()
	defer con.Close()

	// Declare some types to use as dependencies within the example.
	type UpstreamDependency1 struct{}
	type UpstreamDependency2 struct{}
	type Dependency struct {
		Up1 *UpstreamDependency1
		Up2 *UpstreamDependency2
	}

	// Declare a constructor for the Dependency type. It depends on the two
	// upstream dependency types (which are assumed to be declared elsewhere).
	imbue.With2(
		con,
		func(
			ctx imbue.Context,
			up1 *UpstreamDependency1,
			up2 *UpstreamDependency2,
		) (*Dependency, error) {
			return &Dependency{up1, up2}, nil
		},
	)

	// Print the dependency tree.
	fmt.Println(con)
}

Output:

<container>
└── *imbue_test.Dependency
    ├── *imbue_test.UpstreamDependency1
    └── *imbue_test.UpstreamDependency2

func With2Grouped ¶ added in v0.3.0

func With2Grouped[G Group, T, D1, D2 any](
	con ContainerAware,
	ctor func(Context, D1, D2) (T, error),
	options ...WithGroupedOption,
)

With2Grouped describes how to construct grouped values of type T from 2 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With2Named ¶

func With2Named[N Name[T], T, D1, D2 any](
	con ContainerAware,
	ctor func(Context, D1, D2) (T, error),
	options ...WithNamedOption,
)

With2Named describes how to construct named values of type T from 2 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With3 ¶

func With3[T, D1, D2, D3 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3) (T, error),
	options ...WithOption,
)

With3 describes how to construct values of type T from 3 dependencies.

func With3Grouped ¶ added in v0.3.0

func With3Grouped[G Group, T, D1, D2, D3 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3) (T, error),
	options ...WithGroupedOption,
)

With3Grouped describes how to construct grouped values of type T from 3 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With3Named ¶

func With3Named[N Name[T], T, D1, D2, D3 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3) (T, error),
	options ...WithNamedOption,
)

With3Named describes how to construct named values of type T from 3 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With4 ¶

func With4[T, D1, D2, D3, D4 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4) (T, error),
	options ...WithOption,
)

With4 describes how to construct values of type T from 4 dependencies.

func With4Grouped ¶ added in v0.3.0

func With4Grouped[G Group, T, D1, D2, D3, D4 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4) (T, error),
	options ...WithGroupedOption,
)

With4Grouped describes how to construct grouped values of type T from 4 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With4Named ¶

func With4Named[N Name[T], T, D1, D2, D3, D4 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4) (T, error),
	options ...WithNamedOption,
)

With4Named describes how to construct named values of type T from 4 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With5 ¶

func With5[T, D1, D2, D3, D4, D5 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5) (T, error),
	options ...WithOption,
)

With5 describes how to construct values of type T from 5 dependencies.

func With5Grouped ¶ added in v0.3.0

func With5Grouped[G Group, T, D1, D2, D3, D4, D5 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5) (T, error),
	options ...WithGroupedOption,
)

With5Grouped describes how to construct grouped values of type T from 5 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With5Named ¶

func With5Named[N Name[T], T, D1, D2, D3, D4, D5 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5) (T, error),
	options ...WithNamedOption,
)

With5Named describes how to construct named values of type T from 5 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With6 ¶

func With6[T, D1, D2, D3, D4, D5, D6 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6) (T, error),
	options ...WithOption,
)

With6 describes how to construct values of type T from 6 dependencies.

func With6Grouped ¶ added in v0.3.0

func With6Grouped[G Group, T, D1, D2, D3, D4, D5, D6 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6) (T, error),
	options ...WithGroupedOption,
)

With6Grouped describes how to construct grouped values of type T from 6 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With6Named ¶

func With6Named[N Name[T], T, D1, D2, D3, D4, D5, D6 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6) (T, error),
	options ...WithNamedOption,
)

With6Named describes how to construct named values of type T from 6 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With7 ¶

func With7[T, D1, D2, D3, D4, D5, D6, D7 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7) (T, error),
	options ...WithOption,
)

With7 describes how to construct values of type T from 7 dependencies.

func With7Grouped ¶ added in v0.3.0

func With7Grouped[G Group, T, D1, D2, D3, D4, D5, D6, D7 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7) (T, error),
	options ...WithGroupedOption,
)

With7Grouped describes how to construct grouped values of type T from 7 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With7Named ¶

func With7Named[N Name[T], T, D1, D2, D3, D4, D5, D6, D7 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7) (T, error),
	options ...WithNamedOption,
)

With7Named describes how to construct named values of type T from 7 dependencies.

N is the name given to the dependency. T is the type of the dependency.

func With8 ¶

func With8[T, D1, D2, D3, D4, D5, D6, D7, D8 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7, D8) (T, error),
	options ...WithOption,
)

With8 describes how to construct values of type T from 8 dependencies.

func With8Grouped ¶ added in v0.3.0

func With8Grouped[G Group, T, D1, D2, D3, D4, D5, D6, D7, D8 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7, D8) (T, error),
	options ...WithGroupedOption,
)

With8Grouped describes how to construct grouped values of type T from 8 dependencies.

G is the group that contains the dependency. T is the type of the dependency.

func With8Named ¶

func With8Named[N Name[T], T, D1, D2, D3, D4, D5, D6, D7, D8 any](
	con ContainerAware,
	ctor func(Context, D1, D2, D3, D4, D5, D6, D7, D8) (T, error),
	options ...WithNamedOption,
)

With8Named describes how to construct named values of type T from 8 dependencies.

N is the name given to the dependency. T is the type of the dependency.