pureharm-effects-cats/busymachines.pureharm.effects.aliases/CatsAliases

CatsAliases

trait CatsAliases
class Object
trait Matchable
class Any

Type members

Types

final type :<:[F[_], G[_]] = InjectK[F, G]
final type :≺:[F[_], G[_]] = InjectK[F, G]
final type Align[F[_]] = Align[F]
final type Alternative[F[_]] = Alternative[F]
final type Always[A] = Always[A]
final type AndThen[-T, +R] = AndThen[T, R]
final type AppFunc[F[_], A, B] = AppFunc[F, A, B]
final type Applicative[F[_]] = Applicative[F]
final type ApplicativeError[F[_], E] = ApplicativeError[F, E]
final type ApplicativeThrow[F[_]] = ApplicativeThrow[F]
final type Apply[F[_]] = Apply[F]
final type Arrow[F[_, _]] = Arrow[F]
final type ArrowChoice[F[_, _]] = ArrowChoice[F]
final type Bifoldable[F[_, _]] = Bifoldable[F]
final type Bifunctor[F[_, _]] = Bifunctor[F]
final type Bimonad[F[_]] = Bimonad[F]
final type Binested[F[_, _], G[_], H[_], A, B] = Binested[F, G, H, A, B]
final type BinestedBifoldable[F[_, _], G[_], H[_]] = BinestedBifoldable[F, G, H]
final type BinestedBitraverse[F[_, _], G[_], H[_]] = BinestedBitraverse[F, G, H]
final type Bitraverse[F[_, _]] = Bitraverse[F]
final type Category[F[_, _]] = Category[F]
final type Chain[+A] = Chain[A]
final type Choice[F[_, _]] = Choice[F]
final type CoflatMap[F[_]] = CoflatMap[F]
final type Cokleisli[F[_], A, B] = Cokleisli[F, A, B]
final type CommutativeApplicative[F[_]] = CommutativeApplicative[F]
final type CommutativeApply[F[_]] = CommutativeApply[F]
final type CommutativeArrow[F[_, _]] = CommutativeArrow[F]
final type CommutativeFlatMap[F[_]] = CommutativeFlatMap[F]
final type CommutativeMonad[F[_]] = CommutativeMonad[F]
final type Comonad[F[_]] = Comonad[F]
final type Comparison = Comparison
final type Compose[F[_, _]] = Compose[F]
final type Const[A, B] = Const[A, B]
final type Cont[A, B] = Cont[A, B]
final type ContT[M[_], A, +B] = ContT[M, A, B]
final type EitherK[F[_], G[_], A] = EitherK[F, G, A]
final type EitherNec[+E, +A] = Either[Type[E], A]
final type EitherNel[+E, +A] = Either[NonEmptyList[E], A]
final type EitherNes[E, +A] = Either[Type[E], A]
final type EitherT[F[_], L, R] = EitherT[F, L, R]
final type Endo[T] = () => T
final type Eq[A] = Eq[A]
final type Eval[+A] = Eval[A]
final type EvalGroup[A] = EvalGroup[A]
final type EvalMonoid[A] = EvalMonoid[A]
final type EvalSemigroup[A] = EvalSemigroup[A]
final type FlatMap[F[_]] = FlatMap[F]
final type Foldable[F[_]] = Foldable[F]
final type Func[F[_], A, B] = Func[F, A, B]
final type FunctionK[F[_], G[_]] = FunctionK[F, G]
final type Functor[F[_]] = Functor[F]
final type FunctorFilter[F[_]] = FunctorFilter[F]
final type Group[A] = Group[A]
final type Hash[A] = Hash[A]
final type IRWST[F[_], E, L, SA, SB, A] = IndexedReaderWriterStateT[F, E, L, SA, SB, A]
final type IdT[F[_], A] = IdT[F, A]
final type IndexedReaderWriterStateT[F[_], E, L, SA, SB, A] = IndexedReaderWriterStateT[F, E, L, SA, SB, A]
final type IndexedState[S1, S2, A] = IndexedState[S1, S2, A]
final type IndexedStateT[F[_], SA, SB, A] = IndexedStateT[F, SA, SB, A]
final type Inject[A, B] = Inject[A, B]
final type InjectK[F[_], G[_]] = InjectK[F, G]
final type Invariant[F[_]] = Invariant[F]
final type InvariantMonoidal[F[_]] = InvariantMonoidal[F]
final type InvariantSemigroupal[F[_]] = InvariantSemigroupal[F]
final type Ior[+A, +B] = Ior[A, B]
final type IorNec[+B, +A] = Ior[Type[B], A]
final type IorNel[+B, +A] = Ior[NonEmptyList[B], A]
final type IorNes[B, +A] = Ior[Type[B], A]
final type Kleisli[F[_], A, B] = Kleisli[F, A, B]
final type Later[A] = Later[A]
final type Monad[F[_]] = Monad[F]
final type MonadError[F[_], E] = MonadError[F, E]
final type MonadThrow[F[_]] = MonadThrow[F]
final type Monoid[A] = Monoid[A]
final type MonoidK[F[_]] = MonoidK[F]
final type NEChain[+A] = Type[A]
final type NELazyList[+A] = Type[A]
final type NEList[+A] = NonEmptyList[A]
final type NEMap[K, +A] = Type[K, A]
final type NESet[A] = Type[A]
final type Nested[F[_], G[_], A] = Nested[F, G, A]
final type NonEmptyChain[+A] = Type[A]
final type NonEmptyLazyList[+A] = Type[A]
final type NonEmptyList[+A] = NonEmptyList[A]
final type NonEmptyMap[K, +A] = Type[K, A]
final type NonEmptyParallel[F[_]] = NonEmptyParallel[F]
final type NonEmptySet[A] = Type[A]
final type NonEmptyTraverse[F[_]] = NonEmptyTraverse[F]
final type Now[A] = Now[A]
final type OneAnd[F[_], A] = OneAnd[F, A]
final type Op[Arr[_, _], A, B] = Op[Arr, A, B]
final type OptionT[F[_], A] = OptionT[F, A]
final type Order[A] = Order[A]
final type Parallel[F[_]] = Parallel[F]
final type PartialOrder[A] = PartialOrder[A]
final type Profunctor[F[_, _]] = Profunctor[F]
final type RWS[E, L, S, A] = ReaderWriterState[E, L, S, A]
final type RWST[F[_], E, L, S, A] = ReaderWriterStateT[F, E, L, S, A]
final type Reader[A, B] = Reader[A, B]
final type ReaderT[F[_], A, B] = Kleisli[F, A, B]
final type ReaderWriterStateT[F[_], E, L, S, A] = ReaderWriterStateT[F, E, L, S, A]
final type Reducible[F[_]] = Reducible[F]
final type Representable[F[_]] = Representable[F]
final type RepresentableStore[F[_], S, A] = RepresentableStore[F, S, A]
final type Semigroup[A] = Semigroup[A]
final type Semigroupal[F[_]] = Semigroupal[F]
final type Show[T] = Show[T]
final type State[S, A] = State[S, A]
final type StateT[F[_], S, A] = StateT[F, S, A]
final type Store[S, A] = Store[S, A]
final type Strong[F[_, _]] = Strong[F]
final type Traverse[F[_]] = Traverse[F]
final type TraverseFilter[F[_]] = TraverseFilter[F]
final type Tuple2K[F[_], G[_], A] = Tuple2K[F, G, A]
final type UnorderedTraverse[F[_]] = UnorderedTraverse[F]
final type Validated[+E, +A] = Validated[E, A]
final type ValidatedNec[+E, +A] = Validated[Type[E], A]
final type ValidatedNel[+E, +A] = Validated[NonEmptyList[E], A]
final type Writer[L, V] = Writer[L, V]
final type WriterT[F[_], L, V] = WriterT[F, L, V]
final type ~>[F[_], G[_]] = FunctionK[F, G]
final type ⊤ = Any
final type ⊥ = Nothing

Value members

Concrete fields

final val Align: Align
final val Alternative: Alternative
final val Always: Always
final val AndThen: AndThen
final val AppFunc: AppFunc
final val Applicative: Applicative
final val ApplicativeError: ApplicativeError
final val ApplicativeThrow: ApplicativeThrow
final val Apply: Apply
final val Arrow: Arrow
final val ArrowChoice: ArrowChoice
final val Bifoldable: Bifoldable
final val Bifunctor: Bifunctor
final val Bimonad: Bimonad
final val Binested: Binested
final val Bitraverse: Bitraverse
final val Category: Category
final val Chain: Chain
final val Choice: Choice
final val CoflatMap: CoflatMap
final val Cokleisli: Cokleisli
final val CommutativeApplicative: CommutativeApplicative
final val CommutativeApply: CommutativeApply
final val CommutativeArrow: CommutativeArrow
final val CommutativeFlatMap: CommutativeFlatMap
final val CommutativeMonad: CommutativeMonad
final val Comonad: Comonad
final val Comparison: Comparison
final val Compose: Compose
final val Const: Const
final val Cont: Cont
final val ContT: ContT
final val EitherK: EitherK
final val EitherT: EitherT
final val Eq: Eq
final val Eval: Eval
final val FlatMap: FlatMap
final val Foldable: Foldable
final val Func: Func
final val FunctionK: FunctionK
final val Functor: Functor
final val FunctorFilter: FunctorFilter
final val Group: Group
final val Hash: Hash
final val IRWST: IndexedReaderWriterStateT
final val IdT: IdT
final val IndexedReaderWriterStateT: IndexedReaderWriterStateT
final val IndexedState: IndexedState
final val IndexedStateT: IndexedStateT
final val Inject: Inject
final val InjectK: InjectK
final val Invariant: Invariant
final val InvariantMonoidal: InvariantMonoidal
final val InvariantSemigroupal: InvariantSemigroupal
final val Ior: Ior
final val Kleisli: Kleisli
final val Later: Later
final val Monad: Monad
final val MonadError: MonadError
final val MonadThrow: MonadThrow
final val Monoid: Monoid
final val MonoidK: MonoidK
final val NEChain: NonEmptyChainImpl
final val NELazyList: NonEmptyLazyList
final val NEList: NonEmptyList
final val NEMap: NonEmptyMapImpl
final val NESet: NonEmptySetImpl
final val Nested: Nested
final val NonEmptyChain: NonEmptyChainImpl
final val NonEmptyLazyList: NonEmptyLazyList
final val NonEmptyList: NonEmptyList
final val NonEmptyMap: NonEmptyMapImpl
final val NonEmptyParallel: NonEmptyParallel
final val NonEmptySet: NonEmptySetImpl
final val NonEmptyTraverse: NonEmptyTraverse
final val Now: Now
final val OneAnd: OneAnd
final val Op: Op
final val OptionT: OptionT
final val Order: Order
final val Parallel: Parallel
final val PartialOrder: PartialOrder
final val Profunctor: Profunctor
final val RWS: ReaderWriterState
final val RWST: ReaderWriterStateT
final val Reader: Reader
final val ReaderT: Kleisli
final val ReaderWriterStateT: ReaderWriterStateT
final val Reducible: Reducible
final val Representable: Representable
final val RepresentableStore: RepresentableStore
final val Semigroup: Semigroup
final val Semigroupal: Semigroupal
final val Show: Show
final val State: State
final val StateT: StateT
final val Store: Store
final val Strong: Strong
final val Traverse: Traverse
final val TraverseFilter: TraverseFilter
final val Tuple2K: Tuple2K
final val UnorderedTraverse: UnorderedTraverse
final val Validated: Validated
final val Writer: Writer
final val WriterT: WriterT