109 lines
3.1 KiB
Go
109 lines
3.1 KiB
Go
package mo
|
|
|
|
// NewIO instanciates a new IO.
|
|
func NewIO[R any](f f0[R]) IO[R] {
|
|
return IO[R]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO[R any] struct {
|
|
unsafePerform f0[R]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO[R]) Run() R {
|
|
return io.unsafePerform()
|
|
}
|
|
|
|
// NewIO1 instanciates a new IO1.
|
|
func NewIO1[R any, A any](f f1[R, A]) IO1[R, A] {
|
|
return IO1[R, A]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO1 represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO1[R any, A any] struct {
|
|
unsafePerform f1[R, A]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO1[R, A]) Run(a A) R {
|
|
return io.unsafePerform(a)
|
|
}
|
|
|
|
// NewIO2 instanciates a new IO2.
|
|
func NewIO2[R any, A any, B any](f f2[R, A, B]) IO2[R, A, B] {
|
|
return IO2[R, A, B]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO2 represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO2[R any, A any, B any] struct {
|
|
unsafePerform f2[R, A, B]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO2[R, A, B]) Run(a A, b B) R {
|
|
return io.unsafePerform(a, b)
|
|
}
|
|
|
|
// NewIO3 instanciates a new IO3.
|
|
func NewIO3[R any, A any, B any, C any](f f3[R, A, B, C]) IO3[R, A, B, C] {
|
|
return IO3[R, A, B, C]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO3 represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO3[R any, A any, B any, C any] struct {
|
|
unsafePerform f3[R, A, B, C]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO3[R, A, B, C]) Run(a A, b B, c C) R {
|
|
return io.unsafePerform(a, b, c)
|
|
}
|
|
|
|
// NewIO4 instanciates a new IO4.
|
|
func NewIO4[R any, A any, B any, C any, D any](f f4[R, A, B, C, D]) IO4[R, A, B, C, D] {
|
|
return IO4[R, A, B, C, D]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO4 represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO4[R any, A any, B any, C any, D any] struct {
|
|
unsafePerform f4[R, A, B, C, D]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO4[R, A, B, C, D]) Run(a A, b B, c C, d D) R {
|
|
return io.unsafePerform(a, b, c, d)
|
|
}
|
|
|
|
// NewIO5 instanciates a new IO5.
|
|
func NewIO5[R any, A any, B any, C any, D any, E any](f f5[R, A, B, C, D, E]) IO5[R, A, B, C, D, E] {
|
|
return IO5[R, A, B, C, D, E]{
|
|
unsafePerform: f,
|
|
}
|
|
}
|
|
|
|
// IO5 represents a non-deterministic synchronous computation that
|
|
// can cause side effects, yields a value of type `R` and never fails.
|
|
type IO5[R any, A any, B any, C any, D any, E any] struct {
|
|
unsafePerform f5[R, A, B, C, D, E]
|
|
}
|
|
|
|
// Run execute the non-deterministic synchronous computation, with side effect.
|
|
func (io IO5[R, A, B, C, D, E]) Run(a A, b B, c C, d D, e E) R {
|
|
return io.unsafePerform(a, b, c, d, e)
|
|
}
|