interfaces

type Alternative[F_, A any] interface {
	Empty() types.HKT[F_, A]
	Or(types.HKT[F_, A], types.HKT[F_, A]) types.HKT[F_, A]
}

type Applicative[F_, A, B any] interface {
	Apply(types.HKT[F_, func(A) B], types.HKT[F_, A]) types.HKT[F_, B]
}

type Apply[F_, A, B any] interface {
	Product(types.HKT[F_, A], types.HKT[F_, B]) types.HKT[F_, tuple.Tuple2[A, B]]
}

type Async[A any] interface {
	Async(func() A) <-chan A
}

type Bind[F_, A, B any] interface {
	FlatMap(types.HKT[F_, A], func(A) types.HKT[F_, B]) types.HKT[F_, B]
}

type Clone[A any] interface {
	Clone(A) A
}

type Contextual[A any] interface {
	Context(context.Context) A
}

type Debugger[A any] interface {
	Debug(A) string
}

type Debugging interface {
	Debug() string
}

type Default[A any] interface {
	Default() A
}

type DefaultDebug[A any] struct{}

type Enum[A any] interface {
	Succ(A) A
	Pred(A) A
	ToEnum(int) A
	Range(A, A) collection.Iterator[A]
}

type Eq[A, B any] interface {
	Equal(A, B) bool
}

type Foldable[F_, A, B any] interface {
	FoldLeft(types.HKT[F_, A], func(B, A) B, B) B
}

type Hash[T any] interface {
	Hash(T) uint64
}

type HashInt struct{}

type HashString struct{}

type Less[A any] interface {
	LessThan(A, A) bool
}

type LocalAsync[A any] struct{}

type Logger interface {
	Log(string, ...any)
	Info(string, ...any)
	Warn(string, ...any)
	Error(string, ...any)
	Debug(string, ...any)
}

type Monad[F_, A, B any] interface {
	Apply[F_, A, B]
	Bind[F_, A, B]
}

type Order[A any] interface {
	Compare(A, A) Ordering
}

type Ordering int

type Prelude[T comparable] struct{}

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

type Pure[F_, A any] interface {
	Pure(A) types.HKT[F_, A]
}

type Seq[F_, A any] interface {
	SeqInterface[F_, A]
	Append(types.HKT[F_, A], A) types.HKT[F_, A]
	Concat(types.HKT[F_, A], types.HKT[F_, A]) types.HKT[F_, A]
	Count(types.HKT[F_, A], func(A) bool) int
	Find(types.HKT[F_, A], func(A) bool) maybe.Maybe[A]
}

type SeqDefault[F_, A any] struct {
	SeqInterface[F_, A]
}

type SeqInterface[F_, A any] interface {
	impl.Implement[types.HKT[F_, A], collection.Iterable[A]]

	Get(types.HKT[F_, A], int) maybe.Maybe[A]
	Len(types.HKT[F_, A]) int
}

type Sequence[F_, G_, B any] struct {
	Traversable[F_, G_, types.HKT[F_, B], B]
}

type Summoner[A any] interface {
	Summon() maybe.Maybe[A]
	Given(A)
}

type ToComparable[A any, B comparable] interface {
	ToComparable(A) B
}

type Transformation[F_, G_, A any] interface {
	Transform(types.HKT[F_, A]) types.HKT[G_, A]
}

type Traversable[F_, G_, A, B any] interface {
	// Apply[F_, A, B]
	Traverse(
		types.HKT[G_, A],
		func(A) types.HKT[F_, B],
	) types.HKT[F_, types.HKT[G_, B]]
}

type Visualize[F_, A any, M types.HKT[F_, A]] struct {
}