vendor

vendor/github.com/samber/mo/task.go

@@ -0,0 +1,175 @@
+package mo
+
+// NewTask instanciates a new Task.
+func NewTask[R any](f ff0[R]) Task[R] {
+	return Task[R]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO instanciates a new Task from an existing IO.
+func NewTaskFromIO[R any](io IO[R]) Task[R] {
+	return Task[R]{
+		unsafePerform: func() *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform())
+			})
+		},
+	}
+}
+
+// Task represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task[R any] struct {
+	unsafePerform ff0[R]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task[R]) Run() *Future[R] {
+	return t.unsafePerform()
+}
+
+// NewTask1 instanciates a new Task1.
+func NewTask1[R any, A any](f ff1[R, A]) Task1[R, A] {
+	return Task1[R, A]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO1 instanciates a new Task1 from an existing IO1.
+func NewTaskFromIO1[R any, A any](io IO1[R, A]) Task1[R, A] {
+	return Task1[R, A]{
+		unsafePerform: func(a A) *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform(a))
+			})
+		},
+	}
+}
+
+// Task1 represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task1[R any, A any] struct {
+	unsafePerform ff1[R, A]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task1[R, A]) Run(a A) *Future[R] {
+	return t.unsafePerform(a)
+}
+
+// NewTask2 instanciates a new Task2.
+func NewTask2[R any, A any, B any](f ff2[R, A, B]) Task2[R, A, B] {
+	return Task2[R, A, B]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO2 instanciates a new Task2 from an existing IO2.
+func NewTaskFromIO2[R any, A any, B any](io IO2[R, A, B]) Task2[R, A, B] {
+	return Task2[R, A, B]{
+		unsafePerform: func(a A, b B) *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform(a, b))
+			})
+		},
+	}
+}
+
+// Task2 represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task2[R any, A any, B any] struct {
+	unsafePerform ff2[R, A, B]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task2[R, A, B]) Run(a A, b B) *Future[R] {
+	return t.unsafePerform(a, b)
+}
+
+// NewTask3 instanciates a new Task3.
+func NewTask3[R any, A any, B any, C any](f ff3[R, A, B, C]) Task3[R, A, B, C] {
+	return Task3[R, A, B, C]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO3 instanciates a new Task3 from an existing IO3.
+func NewTaskFromIO3[R any, A any, B any, C any](io IO3[R, A, B, C]) Task3[R, A, B, C] {
+	return Task3[R, A, B, C]{
+		unsafePerform: func(a A, b B, c C) *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform(a, b, c))
+			})
+		},
+	}
+}
+
+// Task3 represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task3[R any, A any, B any, C any] struct {
+	unsafePerform ff3[R, A, B, C]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task3[R, A, B, C]) Run(a A, b B, c C) *Future[R] {
+	return t.unsafePerform(a, b, c)
+}
+
+// NewTask4 instanciates a new Task4.
+func NewTask4[R any, A any, B any, C any, D any](f ff4[R, A, B, C, D]) Task4[R, A, B, C, D] {
+	return Task4[R, A, B, C, D]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO4 instanciates a new Task4 from an existing IO4.
+func NewTaskFromIO4[R any, A any, B any, C any, D any](io IO4[R, A, B, C, D]) Task4[R, A, B, C, D] {
+	return Task4[R, A, B, C, D]{
+		unsafePerform: func(a A, b B, c C, d D) *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform(a, b, c, d))
+			})
+		},
+	}
+}
+
+// Task4 represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task4[R any, A any, B any, C any, D any] struct {
+	unsafePerform ff4[R, A, B, C, D]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task4[R, A, B, C, D]) Run(a A, b B, c C, d D) *Future[R] {
+	return t.unsafePerform(a, b, c, d)
+}
+
+// NewTask5 instanciates a new Task5.
+func NewTask5[R any, A any, B any, C any, D any, E any](f ff5[R, A, B, C, D, E]) Task5[R, A, B, C, D, E] {
+	return Task5[R, A, B, C, D, E]{
+		unsafePerform: f,
+	}
+}
+
+// NewTaskFromIO5 instanciates a new Task5 from an existing IO5.
+func NewTaskFromIO5[R any, A any, B any, C any, D any, E any](io IO5[R, A, B, C, D, E]) Task5[R, A, B, C, D, E] {
+	return Task5[R, A, B, C, D, E]{
+		unsafePerform: func(a A, b B, c C, d D, e E) *Future[R] {
+			return NewFuture[R](func(resolve func(R), reject func(error)) {
+				resolve(io.unsafePerform(a, b, c, d, e))
+			})
+		},
+	}
+}
+
+// Task5 represents a non-deterministic asynchronous computation that
+// can cause side effects, yields a value of type `R` and never fails.
+type Task5[R any, A any, B any, C any, D any, E any] struct {
+	unsafePerform ff5[R, A, B, C, D, E]
+}
+
+// Run execute the non-deterministic asynchronous computation, with side effect.
+func (t Task5[R, A, B, C, D, E]) Run(a A, b B, c C, d D, e E) *Future[R] {
+	return t.unsafePerform(a, b, c, d, e)
+}