nutcracker/nutcracker.util.typealigned

nutcracker.util.typealigned

package nutcracker.util.typealigned

Type members

Classlikes

final case class ACons[F[_, _], A, B, C](head: F[A, B], tail1: AList1[F, B, C]) extends AList1[F, A, C]
final case class AJust[F[_, _], A, B](value: F[A, B]) extends AList1[F, A, B]
final class AList[F[_, _], A, B] extends AnyVal

A potentially empty type-aligned list.

A potentially empty type-aligned list.

Companion:
object
object AList
Companion:
class
sealed abstract class AList1[F[_, _], A, B]

Type-aligned list with at least 1 element. Example:

Type-aligned list with at least 1 element. Example:

F[A, X], F[X, Y], F[Y, Z], F[Z, B]
Companion:
object
object AList1
Companion:
class
case class ANone[F[_, _], A, B](ev: A === B) extends AOption[F, A, B]

The empty case contains evidence of type equality to overcome the limitations of pattern-matching on GADTs.

The empty case contains evidence of type equality to overcome the limitations of pattern-matching on GADTs.

sealed abstract class AOption[F[_, _], A, B]

Similar to Option[F[A, B]], but the empty case witnesses type equality between A and B.

Similar to Option[F[A, B]], but the empty case witnesses type equality between A and B.

Companion:
object
object AOption
Companion:
class
object APair
case class ASome[F[_, _], A, B](value: F[A, B]) extends AOption[F, A, B]
final case class BalancedAppender[A] extends AnyVal
Companion:
object
object BalancedAppender
Companion:
class
final class BalancedComposer[F[_, _], A, B, Dir]
Companion:
object
object BalancedComposer
Companion:
class
object BalancedPostComposer
object BalancedPreComposer
final case class BalancedPrepender[A] extends AnyVal
Companion:
object
object BalancedPrepender
Companion:
class
sealed abstract class BoundedAPair[U, F[_ <: U], G[_ <: U]]
Companion:
object
object BoundedAPair
Companion:
class
sealed abstract class FreeCompose[=>:[_, _], A, B]

FreeCompose is a non-empty type-aligned sequence represented as a (non-balanced) binary tree, in order to support O(1) addition to either side and O(1) concatenation.

FreeCompose is a non-empty type-aligned sequence represented as a (non-balanced) binary tree, in order to support O(1) addition to either side and O(1) concatenation.

Companion:
object
object FreeCompose
Companion:
class
trait FunctorLike[F[_], =>:[_, _]]

Has the map operation of a functor. When =>: forms a category (on Scala types), then FunctorLike is a functor if it satisfies the functor laws.

Has the map operation of a functor. When =>: forms a category (on Scala types), then FunctorLike is a functor if it satisfies the functor laws.

Companion:
object
object FunctorLike
Companion:
class

Types

type APair[F[_], G[_]] = BoundedAPair[Any, F, G]

Type-aligned pair.

Type-aligned pair.

type BalancedPostComposer[F[_, _], A, B] = BalancedComposer[[_, _] =>> Op[F, _$12, _$13], B, A, Post]

Binary counter-like accumulator for type-aligned binary type constructors, with the most significant bit on the left and addition of new elements (i.e. "increment") from the right.

Binary counter-like accumulator for type-aligned binary type constructors, with the most significant bit on the left and addition of new elements (i.e. "increment") from the right.

type BalancedPreComposer[F[_, _], A, B] = BalancedComposer[F, A, B, Pre]

Binary counter-like accumulator for type-aligned binary type constructors, with the most significant bit on the right and addition of new elements (i.e. "increment") from the left.

Binary counter-like accumulator for type-aligned binary type constructors, with the most significant bit on the right and addition of new elements (i.e. "increment") from the left.

type ContravariantLike[F[_], ->[_, _]] = FunctorLike[F, [_, _] =>> Op[->, _$8, _$9]]

Contravariant functor is a (covariant) functor in the opposite category.

Contravariant functor is a (covariant) functor in the opposite category.

type Op[F[_, _], A, B] = F[B, A]