Type Members
-
-
type
BuildKeyConstraint[K] = DummyImplicit
-
-
type
Id[+X] = X
-
type
Identity[+X] = Need[X]
-
trait
LiftV[F[_], A, B] extends Ops[(A) ⇒ B]
-
class
ParsersW[P <: scala.util.parsing.combinator.Parsers] extends AnyRef
-
final
class
UnzipPairOps[F[_], A, B] extends AnyRef
-
type
XMap[K, V] = Map[K, V]
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
-
final
def
<^>[A, B](as: List[A])(f: (NonEmptyList[A]) ⇒ B)(implicit arg0: Monoid[B]): B
-
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
implicit
def
ApplicativeIdV[A](v: ⇒ A): ApplicativeIdV[A] { lazy val self: A }
-
implicit
def
FirstLeftProjectionEIso2[E]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]
-
implicit
val
FirstLeftProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
-
implicit
def
FirstRightProjectionAIso2[A]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]
-
implicit
val
FirstRightProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
-
implicit
def
LastLeftProjectionEIso2[E]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]
-
implicit
val
LastLeftProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
-
implicit
def
LastRightProjectionAIso2[A]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]
-
implicit
val
LastRightProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
-
implicit
def
LeftProjectionEIso2[E]: Isomorphism.<~>[[α]LeftProjection[E, α], [α]Either[E, α]]
-
implicit
val
LeftProjectionIso2: Isomorphism.<~~>[LeftProjection, Either]
-
implicit
def
RightProjectionAIso2[A]: Isomorphism.<~>[[α]RightProjection[α, A], [α]Either[α, A]]
-
implicit
val
RightProjectionIso2: Isomorphism.<~~>[RightProjection, Either]
-
implicit
def
ToAlignOps[F[_], A](v: F[A])(implicit F0: Align[F]): AlignOps[F, A]
-
implicit
def
ToAlignOpsUnapply[FA](v: FA)(implicit F0: Unapply[Align, FA]): AlignOps[M, A]
-
implicit
def
ToApplicativeOps[F[_], A](v: F[A])(implicit F0: Applicative[F]): ApplicativeOps[F, A]
-
implicit
def
ToApplicativeOpsUnapply[FA](v: FA)(implicit F0: Unapply[Applicative, FA]): ApplicativeOps[M, A]
-
implicit
def
ToApplicativePlusOps[F[_], A](v: F[A])(implicit F0: ApplicativePlus[F]): ApplicativePlusOps[F, A]
-
-
implicit
def
ToApplyOps[F[_], A](v: F[A])(implicit F0: Apply[F]): ApplyOps[F, A]
-
implicit
def
ToApplyOpsUnapply[FA](v: FA)(implicit F0: Unapply[Apply, FA]): ApplyOps[M, A]
-
implicit
def
ToArrowOps[F[_, _], A, B](v: F[A, B])(implicit F0: Arrow[F]): ArrowOps[F, A, B]
-
implicit
def
ToArrowOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Arrow, FA]): ArrowOps[M, A, B]
-
implicit
def
ToArrowVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Arrow[[α, β]F[G, α, β]]): ArrowOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToAssociativeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Associative[F]): AssociativeOps[F, A, B]
-
implicit
def
ToAssociativeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Associative, FA]): AssociativeOps[M, A, B]
-
implicit
def
ToAssociativeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Associative[[α, β]F[G, α, β]]): AssociativeOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToBifoldableOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifoldable[F]): BifoldableOps[F, A, B]
-
implicit
def
ToBifoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifoldable, FA]): BifoldableOps[M, A, B]
-
implicit
def
ToBifoldableVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifoldable[[α, β]F[G, α, β]]): BifoldableOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToBifunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifunctor[F]): BifunctorOps[F, A, B]
-
implicit
def
ToBifunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifunctor, FA]): BifunctorOps[M, A, B]
-
implicit
def
ToBifunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifunctor[[α, β]F[G, α, β]]): BifunctorOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToBindOps[F[_], A](v: F[A])(implicit F0: Bind[F]): BindOps[F, A]
-
implicit
def
ToBindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Bind, FA]): BindOps[M, A]
-
implicit
def
ToBitraverseOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bitraverse[F]): BitraverseOps[F, A, B]
-
implicit
def
ToBitraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bitraverse, FA]): BitraverseOps[M, A, B]
-
implicit
def
ToBitraverseVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bitraverse[[α, β]F[G, α, β]]): BitraverseOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToBooleanOpsFromBoolean(a: Boolean): BooleanOps
-
implicit
def
ToCatchableOps[F[_], A](v: F[A])(implicit F0: Catchable[F]): CatchableOps[F, A]
-
implicit
def
ToCatchableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Catchable, FA]): CatchableOps[M, A]
-
implicit
def
ToCategoryOps[F[_, _], A, B](v: F[A, B])(implicit F0: Category[F]): CategoryOps[F, A, B]
-
implicit
def
ToCategoryOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Category, FA]): CategoryOps[M, A, B]
-
implicit
def
ToCategoryVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Category[[α, β]F[G, α, β]]): CategoryOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: Choice[F]): ChoiceOps[F, A, B]
-
implicit
def
ToChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Choice, FA]): ChoiceOps[M, A, B]
-
implicit
def
ToChoiceVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Choice[[α, β]F[G, α, β]]): ChoiceOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToCobindOps[F[_], A](v: F[A])(implicit F0: Cobind[F]): CobindOps[F, A]
-
implicit
def
ToCobindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Cobind, FA]): CobindOps[M, A]
-
implicit
def
ToComonadOps[F[_], A](v: F[A])(implicit F0: Comonad[F]): ComonadOps[F, A]
-
implicit
def
ToComonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Comonad, FA]): ComonadOps[M, A]
-
implicit
def
ToComposeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Compose[F]): ComposeOps[F, A, B]
-
implicit
def
ToComposeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Compose, FA]): ComposeOps[M, A, B]
-
implicit
def
ToComposeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Compose[[α, β]F[G, α, β]]): ComposeOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToContravariantOps[F[_], A](v: F[A])(implicit F0: Contravariant[F]): ContravariantOps[F, A]
-
-
implicit
def
ToCozipOps[F[_], A](v: F[A])(implicit F0: Cozip[F]): CozipOps[F, A]
-
implicit
def
ToCozipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Cozip, FA]): CozipOps[M, A]
-
implicit
def
ToEachOps[F[_], A](v: F[A])(implicit F0: Each[F]): EachOps[F, A]
-
implicit
def
ToEachOpsUnapply[FA](v: FA)(implicit F0: Unapply[Each, FA]): EachOps[M, A]
-
implicit
def
ToEitherOps[A](a: A): EitherOps[A]
-
implicit
def
ToEitherOpsFromEither[A, B](e: Either[A, B]): EitherOps[A, B]
-
implicit
def
ToEnumOps[F](v: F)(implicit F0: Enum[F]): EnumOps[F]
-
implicit
def
ToEqualOps[F](v: F)(implicit F0: Equal[F]): EqualOps[F]
-
implicit
def
ToFoldable1Ops[F[_], A](v: F[A])(implicit F0: Foldable1[F]): Foldable1Ops[F, A]
-
implicit
def
ToFoldable1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable1, FA]): Foldable1Ops[M, A]
-
implicit
def
ToFoldableOps[F[_], A](v: F[A])(implicit F0: Foldable[F]): FoldableOps[F, A]
-
implicit
def
ToFoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable, FA]): FoldableOps[M, A]
-
implicit
def
ToFunction1OpsFromBoolean[A, B](f: (A) ⇒ B): Function1Ops[A, B]
-
implicit
def
ToFunction2Ops[T1, T2, R](f: (T1, T2) ⇒ R): Function2Ops[T1, T2, R]
-
implicit
def
ToFunctorIdV[A](v: A): FunctorIdV[A]
-
implicit
def
ToFunctorOps[F[_], A](v: F[A])(implicit F0: Functor[F]): FunctorOps[F, A]
-
implicit
def
ToFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[Functor, FA]): FunctorOps[M, A]
-
implicit
def
ToIdOps[A](a: A): IdOps[A]
-
implicit
def
ToIndexOps[F[_], A](v: F[A])(implicit F0: Index[F]): IndexOps[F, A]
-
implicit
def
ToIndexOpsUnapply[FA](v: FA)(implicit F0: Unapply[Index, FA]): IndexOps[M, A]
-
implicit
def
ToInvariantFunctorOps[F[_], A](v: F[A])(implicit F0: InvariantFunctor[F]): InvariantFunctorOps[F, A]
-
-
implicit
def
ToKleisliFAOps[F[_], A](fa: F[A]): KleisliFAOps[F, A]
-
implicit
def
ToKleisliIdOps[A](a: A): KleisliIdOps[A]
-
implicit
def
ToKleisliOpsUnapply[FA](v: FA)(implicit F0: Unapply[Monad, FA]): KleisliFAOps[M, A]
-
implicit
def
ToLengthOps[F[_], A](v: F[A])(implicit F0: Length[F]): LengthOps[F, A]
-
implicit
def
ToLengthOpsUnapply[FA](v: FA)(implicit F0: Unapply[Length, FA]): LengthOps[M, A]
-
implicit
def
ToLiftV[F[_], A, B](v: (A) ⇒ B): LiftV[F, A, B]
-
implicit
def
ToListOpsFromList[A](a: List[A]): ListOps[A]
-
-
implicit
def
ToMaybeOps[A](a: A): MaybeOps[A]
-
implicit
def
ToMetricSpaceOps[F](v: F)(implicit F0: MetricSpace[F]): MetricSpaceOps[F]
-
implicit
def
ToMonadErrorIdOps[E](v: E): MonadErrorIdOps[E]
-
implicit
def
ToMonadErrorOps[F[_, _], E, A](v: F[E, A])(implicit F: MonadError[F, E]): MonadErrorOps[F, E, A]
-
implicit
def
ToMonadListenOps[F[_, _], A, W](v: F[W, A])(implicit F0: MonadListen[F, W]): MonadListenOps[F, W, A]
-
implicit
def
ToMonadListenOpsUnapply[FA](v: FA)(implicit F0: Unapply21[MonadListen, FA]): MonadListenOps[M, A, B]
-
implicit
def
ToMonadOps[F[_], A](v: F[A])(implicit F0: Monad[F]): MonadOps[F, A]
-
implicit
def
ToMonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Monad, FA]): MonadOps[M, A]
-
implicit
def
ToMonadPlusOps[F[_], A](v: F[A])(implicit F0: MonadPlus[F]): MonadPlusOps[F, A]
-
implicit
def
ToMonadPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[MonadPlus, FA]): MonadPlusOps[M, A]
-
implicit
def
ToMonadTellOps[F[_, _], A, W](v: F[W, A])(implicit F0: MonadTell[F, W]): MonadTellOps[F, W, A]
-
implicit
def
ToMonadTellOpsUnapply[FA](v: FA)(implicit F0: Unapply21[MonadTell, FA]): MonadTellOps[M, A, B]
-
implicit
def
ToMonoidOps[F](v: F)(implicit F0: Monoid[F]): MonoidOps[F]
-
implicit
def
ToNelOps[A](a: A): NelOps[A]
-
implicit
def
ToOptionIdOps[A](a: A): OptionIdOps[A]
-
implicit
def
ToOptionOpsFromOption[A](a: Option[A]): OptionOps[A]
-
implicit
def
ToOptionalOps[F[_], A](v: F[A])(implicit F0: Optional[F]): OptionalOps[F, A]
-
implicit
def
ToOptionalOpsUnapply[FA](v: FA)(implicit F0: Unapply[Optional, FA]): OptionalOps[M, A]
-
implicit
def
ToOrderOps[F](v: F)(implicit F0: Order[F]): OrderOps[F]
-
implicit
def
ToPlusEmptyOps[F[_], A](v: F[A])(implicit F0: PlusEmpty[F]): PlusEmptyOps[F, A]
-
implicit
def
ToPlusEmptyOpsUnapply[FA](v: FA)(implicit F0: Unapply[PlusEmpty, FA]): PlusEmptyOps[M, A]
-
implicit
def
ToPlusOps[F[_], A](v: F[A])(implicit F0: Plus[F]): PlusOps[F, A]
-
implicit
def
ToPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[Plus, FA]): PlusOps[M, A]
-
implicit
def
ToProChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: ProChoice[F]): ProChoiceOps[F, A, B]
-
implicit
def
ToProChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[ProChoice, FA]): ProChoiceOps[M, A, B]
-
implicit
def
ToProChoiceVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: ProChoice[[α, β]F[G, α, β]]): ProChoiceOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToProfunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Profunctor[F]): ProfunctorOps[F, A, B]
-
implicit
def
ToProfunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Profunctor, FA]): ProfunctorOps[M, A, B]
-
implicit
def
ToProfunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Profunctor[[α, β]F[G, α, β]]): ProfunctorOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToReducerOps[A](a: A): ReducerOps[A]
-
final
def
ToScalazOrderFromOrdering[A](oa: scala.math.Ordering[A]): Order[A]
-
implicit
def
ToSemigroupOps[F](v: F)(implicit F0: Semigroup[F]): SemigroupOps[F]
-
implicit
def
ToShowOps[F](v: F)(implicit F0: Show[F]): ShowOps[F]
-
implicit
def
ToSplitOps[F[_, _], A, B](v: F[A, B])(implicit F0: Split[F]): SplitOps[F, A, B]
-
implicit
def
ToSplitOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Split, FA]): SplitOps[M, A, B]
-
implicit
def
ToSplitVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Split[[α, β]F[G, α, β]]): SplitOps[[α, β]F[G, α, β], A, B]
-
implicit
def
ToStateOps[A](a: A): StateOps[A]
-
implicit
def
ToStreamOpsFromStream[A](a: Stream[A]): StreamOps[A]
-
implicit
def
ToStringOpsFromString(a: String): StringOps
-
implicit
def
ToTheseOps[A](a: A): TheseOps[A]
-
implicit
def
ToThesePairOps[A, B](a: (A, B)): ThesePairOps[A, B]
-
implicit
def
ToTraverse1Ops[F[_], A](v: F[A])(implicit F0: Traverse1[F]): Traverse1Ops[F, A]
-
implicit
def
ToTraverse1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse1, FA]): Traverse1Ops[M, A]
-
implicit
def
ToTraverseOps[F[_], A](v: F[A])(implicit F0: Traverse[F]): TraverseOps[F, A]
-
implicit
def
ToTraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse, FA]): TraverseOps[M, A]
-
implicit
def
ToTreeOps[A](a: A): TreeOps[A]
-
implicit
def
ToTuple10Ops[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): Tuple10Ops[A, B, C, D, E, F, G, H, I, J]
-
implicit
def
ToTuple11Ops[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): Tuple11Ops[A, B, C, D, E, F, G, H, I, J, K]
-
implicit
def
ToTuple12Ops[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): Tuple12Ops[A, B, C, D, E, F, G, H, I, J, K, L]
-
implicit
def
ToTuple2Ops[A, B](t: (A, B)): Tuple2Ops[A, B]
-
implicit
def
ToTuple3Ops[A, B, C](t: (A, B, C)): Tuple3Ops[A, B, C]
-
implicit
def
ToTuple4Ops[A, B, C, D](t: (A, B, C, D)): Tuple4Ops[A, B, C, D]
-
implicit
def
ToTuple5Ops[A, B, C, D, E](t: (A, B, C, D, E)): Tuple5Ops[A, B, C, D, E]
-
implicit
def
ToTuple6Ops[A, B, C, D, E, F](t: (A, B, C, D, E, F)): Tuple6Ops[A, B, C, D, E, F]
-
implicit
def
ToTuple7Ops[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): Tuple7Ops[A, B, C, D, E, F, G]
-
implicit
def
ToTuple8Ops[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): Tuple8Ops[A, B, C, D, E, F, G, H]
-
implicit
def
ToTuple9Ops[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): Tuple9Ops[A, B, C, D, E, F, G, H, I]
-
implicit
def
ToUnzipOps[F[_], A](v: F[A])(implicit F0: Unzip[F]): UnzipOps[F, A]
-
implicit
def
ToUnzipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Unzip, FA]): UnzipOps[M, A]
-
implicit
def
ToUnzipPairOps[F[_], A, B](v: F[(A, B)])(implicit F0: Unzip[F]): UnzipPairOps[F, A, B]
-
implicit
def
ToValidationOps[A](a: A): ValidationOps[A]
-
implicit
def
ToVectorOpsFromVector[A](a: Vector[A]): IndexedSeqOps[Vector, A]
-
implicit
def
ToWriterOps[A](a: A): WriterOps[A]
-
implicit
def
ToZipOps[F[_], A](v: F[A])(implicit F0: Zip[F]): ZipOps[F, A]
-
implicit
def
ToZipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Zip, FA]): ZipOps[M, A]
-
def
^[F[_], A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C)(implicit F: Apply[F]): F[C]
-
def
^^[F[_], A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D)(implicit F: Apply[F]): F[D]
-
def
^^^[F[_], A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E)(implicit F: Apply[F]): F[E]
-
def
^^^^[F[_], A, B, C, D, E, I](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ I)(implicit F: Apply[F]): F[I]
-
def
^^^^^[F[_], A, B, C, D, E, I, J](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I])(f: (A, B, C, D, E, I) ⇒ J)(implicit F: Apply[F]): F[J]
-
def
^^^^^^[F[_], A, B, C, D, E, I, J, K](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, I, J) ⇒ K)(implicit F: Apply[F]): F[K]
-
final
def
ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]
-
final
def
ab_-[K, V](m: XMap[K, V], k: K)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]
-
final
def
adjacentPairs[A](as: List[A]): List[(A, A)]
-
final
def
allPairs[A](as: List[A]): List[(A, A)]
-
final
def
alter[K, A](m: XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
-
final
def
asInstanceOf[T0]: T0
-
implicit
val
booleanConjunctionNewTypeInstance: Monoid[@@[Boolean, Conjunction]] with Enum[@@[Boolean, Conjunction]]
-
-
implicit
object
booleanInstance extends Enum[Boolean] with Show[Boolean]
-
final
def
breakM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]
-
final
def
buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]
-
implicit
val
byteInstance: Monoid[Byte] with Enum[Byte] with Show[Byte]
-
-
final
def
cata[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X
-
implicit
val
char: Monoid[Char] with Enum[Char] with Show[Char]
-
-
-
def
charsNel(s: String): Option[NonEmptyList[Char]]
-
def
charsNelErr(s: String, message: ⇒ String): NonEmptyList[Char]
-
def
clone(): AnyRef
-
final
def
conditional(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
conjunction(p: Boolean, q: ⇒ Boolean): Boolean
-
def
constantIndexedState[S1, S2, A](a: A, s: ⇒ S2): IndexedState[S1, S2, A]
-
def
constantState[S, A](a: A, s: ⇒ S): State[S, A]
-
final
def
disjunction(p: Boolean, q: ⇒ Boolean): Boolean
-
implicit
val
doubleInstance: Order[Double] with Show[Double]
-
implicit
def
eitherEqual[A, B](implicit A0: Equal[A], B0: Equal[B]): Equal[Either[A, B]]
-
implicit
def
eitherFirstLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], First]]
-
implicit
val
eitherFirstLeftInstance: IsomorphismBifunctor[[a, b]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
-
implicit
def
eitherFirstLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], First]]
-
implicit
def
eitherFirstLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], First]]
-
implicit
def
eitherFirstLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
-
implicit
def
eitherFirstLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], First]]
-
implicit
def
eitherFirstRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], First]]
-
implicit
def
eitherFirstRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
-
implicit
def
eitherFirstRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], First]]
-
implicit
def
eitherFirstRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], First]]
-
implicit
def
eitherFirstRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], First]]
-
implicit
val
eitherInstance: Bitraverse[Either]
-
implicit
def
eitherLastLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], Last]]
-
implicit
def
eitherLastLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], Last]]
-
implicit
def
eitherLastLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], Last]]
-
implicit
def
eitherLastLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
-
implicit
def
eitherLastLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], Last]]
-
implicit
def
eitherLastRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], Last]]
-
implicit
def
eitherLastRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
-
implicit
def
eitherLastRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], Last]]
-
implicit
def
eitherLastRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], Last]]
-
implicit
def
eitherLastRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], Last]]
-
implicit
def
eitherLeftEqual[A, X](implicit A0: Equal[A]): Equal[LeftProjection[A, X]]
-
implicit
val
eitherLeftInstance: IsomorphismBifunctor[LeftProjection, Either]
-
implicit
def
eitherLeftMonoid[A, X](implicit MonoidA: Monoid[A], MonoidX: Monoid[X]): Monoid[LeftProjection[A, X]]
-
implicit
def
eitherLeftOrder[A, X](implicit OrderA: Order[A]): Order[LeftProjection[A, X]]
-
implicit
def
eitherLeftRInstance[R]: Monad[[α]LeftProjection[α, R]] { def point[A](a: => A): scala.util.Either.LeftProjection[A,Nothing] }
-
implicit
def
eitherLeftSemigroup[A, X](implicit SemigroupA: Semigroup[A], MonoidX: Monoid[X]): Semigroup[LeftProjection[A, X]]
-
implicit
def
eitherMonad[L]: Traverse[[a]Either[L, a]] with Monad[[a]Either[L, a]] with Cozip[[a]Either[L, a]] { def point[A](a: => A): scala.util.Right[Nothing,A] }
-
implicit
def
eitherOrder[A, B](implicit OrderA: Order[A], OrderB: Order[B]): Order[Either[A, B]]
-
implicit
def
eitherRightEqual[X, A](implicit A0: Equal[A]): Equal[RightProjection[X, A]]
-
implicit
val
eitherRightInstance: IsomorphismBifunctor[RightProjection, Either]
-
implicit
def
eitherRightLInstance[L]: Monad[[α]RightProjection[L, α]] { def point[A](a: => A): scala.util.Either.RightProjection[Nothing,A] }
-
implicit
def
eitherRightMonoid[X, A](implicit MonoidX: Monoid[X], MonoidA: Monoid[A]): Monoid[RightProjection[X, A]]
-
implicit
def
eitherRightOrder[X, A](implicit OrderA: Order[A]): Order[RightProjection[X, A]]
-
implicit
def
eitherRightSemigroup[X, A](implicit MonoidX: Monoid[X], SemigroupA: Semigroup[A]): Semigroup[RightProjection[X, A]]
-
final
def
emptyOrPure[M[_], A](cond: Boolean)(a: ⇒ A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A]
-
final
def
emptyOrPureNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): ~>[Id.Id, M]
-
def
encode(s: String)(implicit c: CharSet): Array[Byte]
-
implicit
def
enumInstance[E <: java.lang.Enum[E]]: Equal[E]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
final
def
filterM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Applicative[M]): M[List[A]]
-
def
finalize(): Unit
-
final
def
findM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[Option[A]]
-
final
def
fix[A](f: (⇒ A) ⇒ A): A
-
implicit
val
floatInstance: Order[Float] with Show[Float]
-
final
def
fold[A](cond: Boolean, t: ⇒ A, f: ⇒ A): A
-
final
def
fold[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X
-
final
def
foldLift[F[_], A, B](oa: Option[A])(b: ⇒ B, k: (F[A]) ⇒ B)(implicit p: Applicative[F]): B
-
final
def
foldLiftOpt[A, B](oa: Option[A])(b: ⇒ B, k: (Option[A]) ⇒ B): B
-
implicit
def
function0Equal[R](implicit arg0: Equal[R]): Equal[() ⇒ R]
-
implicit
val
function0Instance: Traverse[Function0] with Monad[Function0] with Comonad[Function0] with Distributive[Function0]
-
implicit
def
function1Cobind[A, R](implicit A0: Semigroup[A]): Cobind[[α](A) ⇒ α]
-
implicit
def
function1Comonad[A, R](implicit A0: Monoid[A]): Comonad[[α](A) ⇒ α]
-
implicit
def
function1Contravariant[R]: Contravariant[[a](a) ⇒ R]
-
implicit
def
function1Covariant[T]: Monad[[a](T) ⇒ a] with Zip[[a](T) ⇒ a] with Unzip[[a](T) ⇒ a] with Distributive[[a](T) ⇒ a]
-
implicit
def
function1CovariantByName[T]: Monad[[a](⇒ T) ⇒ a] with Zip[[a](⇒ T) ⇒ a] with Unzip[[a](⇒ T) ⇒ a] with Distributive[[a](⇒ T) ⇒ a]
-
implicit
val
function1Instance: Arrow[Function1] with Category[Function1] with Choice[Function1]
-
implicit
def
function1Monoid[A, R](implicit R0: Monoid[R]): Monoid[(A) ⇒ R]
-
implicit
def
function1Semigroup[A, R](implicit R0: Semigroup[R]): Semigroup[(A) ⇒ R]
-
implicit
def
function2Instance[T1, T2]: Monad[[a](T1, T2) ⇒ a]
-
implicit
def
function3Instance[T1, T2, T3]: Monad[[a](T1, T2, T3) ⇒ a]
-
implicit
def
function4Instance[T1, T2, T3, T4]: Monad[[a](T1, T2, T3, T4) ⇒ a]
-
implicit
def
function5Instance[T1, T2, T3, T4, T5]: Monad[[a](T1, T2, T3, T4, T5) ⇒ a]
-
implicit
def
function6Instance[T1, T2, T3, T4, T5, T6]: Monad[[a](T1, T2, T3, T4, T5, T6) ⇒ a]
-
implicit
def
function7Instance[T1, T2, T3, T4, T5, T6, T7]: Monad[[a](T1, T2, T3, T4, T5, T6, T7) ⇒ a]
-
implicit
def
function8Instance[T1, T2, T3, T4, T5, T6, T7, T8]: Monad[[a](T1, T2, T3, T4, T5, T6, T7, T8) ⇒ a]
-
def
futureComonad(duration: Duration)(implicit executionContext: ExecutionContext): Comonad[Future]
-
implicit
def
futureInstance(implicit ec: ExecutionContext): Monad[Future] with Cobind[Future]
-
implicit
def
futureMonoid[A](implicit g: Monoid[A], ec: ExecutionContext): Monoid[Future[A]]
-
implicit
def
futureSemigroup[A](implicit m: Semigroup[A], ec: ExecutionContext): Semigroup[Future[A]]
-
-
def
get[S]: State[S, S]
-
final
def
getClass(): Class[_]
-
final
def
getOrAdd[F[_], K, A](m: XMap[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F], K: BuildKeyConstraint[K]): F[(XMap[K, A], A)]
-
def
gets[S, T](f: (S) ⇒ T): State[S, T]
-
final
def
groupBy1[A, B](as: List[A])(f: (A) ⇒ B): Map[B, NonEmptyList[A]]
-
final
def
groupWhen[A](as: List[A])(p: (A, A) ⇒ Boolean): List[NonEmptyList[A]]
-
final
def
groupWhenM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[NonEmptyList[A]]]
-
def
hashCode(): Int
-
final
def
heads[A](as: Stream[A]): Stream[Stream[A]]
-
def
iModify[S1, S2](f: (S1) ⇒ S2): IndexedState[S1, S2, Unit]
-
def
iPut[S1, S2](s: S2): IndexedState[S1, S2, Unit]
-
-
def
init[S]: State[S, S]
-
final
def
initz[A](as: List[A]): List[List[A]]
-
final
def
insertWith[K, A](m1: XMap[K, A], k: K, v: A)(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
-
implicit
val
intInstance: Monoid[Int] with Enum[Int] with Show[Int]
-
-
final
def
interleave[A](s1: Stream[A], s2: Stream[A]): Stream[A]
-
final
def
intersectWith[K, A, B, C](m1: XMap[K, A], m2: XMap[K, B])(f: (A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]
-
final
def
intersectWithKey[K, A, B, C](m1: XMap[K, A], m2: XMap[K, B])(f: (K, A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]
-
final
def
intersperse[A](as: Stream[A], a: A): Stream[A]
-
final
def
intersperse[A](as: List[A], a: A): List[A]
-
final
def
inverseConditional(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
implicit
def
lift2[F[_], A, B, C](f: (A, B) ⇒ C)(implicit F: Apply[F]): (F[A], F[B]) ⇒ F[C]
-
implicit
def
lift3[F[_], A, B, C, D](f: (A, B, C) ⇒ D)(implicit F: Apply[F]): (F[A], F[B], F[C]) ⇒ F[D]
-
implicit
def
lift4[F[_], A, B, C, D, E](f: (A, B, C, D) ⇒ E)(implicit F: Apply[F]): (F[A], F[B], F[C], F[D]) ⇒ F[E]
-
implicit
def
listEqual[A](implicit A0: Equal[A]): Equal[List[A]]
-
implicit
val
listInstance: Traverse[List] with MonadPlus[List] with Each[List] with Index[List] with Length[List] with Zip[List] with Unzip[List] with Align[List] with IsEmpty[List] with Cobind[List] { def empty[A]: scala.collection.immutable.Nil.type }
-
implicit
def
listMonoid[A]: Monoid[List[A]]
-
implicit
def
listOrder[A](implicit A0: Order[A]): Order[List[A]]
-
implicit
def
listShow[A](implicit arg0: Show[A]): Show[List[A]]
-
implicit
val
longInstance: Monoid[Long] with Enum[Long] with Show[Long]
-
-
final
def
mapAccumLeft[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])
-
final
def
mapAccumRight[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])
-
implicit
val
mapEntryBitraverse: Bitraverse[Entry]
-
implicit
def
mapEqual[K, V](implicit arg0: Order[K], arg1: Equal[V]): Equal[XMap[K, V]]
-
implicit
def
mapFoldable[K]: Foldable[[V]XMap[K, V]]
-
-
final
def
mapKeys[K, K2, A](m: XMap[K, A])(f: (K) ⇒ K2)(implicit arg0: BuildKeyConstraint[K2]): XMap[K2, A]
-
-
implicit
def
mapOrder[K, V](implicit arg0: Order[K], arg1: Order[V]): Order[XMap[K, V]]
-
implicit
def
mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[XMap[K, V]]
-
def
mempty[F[_], A](implicit F: PlusEmpty[F]): F[A]
-
def
modify[S](f: (S) ⇒ S): State[S, Unit]
-
def
mzero[F](implicit F: Monoid[F]): F
-
final
def
nand(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
negConditional(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
negInverseConditional(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
nil[A]: List[A]
-
final
def
none[A]: Option[A]
-
final
def
nor(p: Boolean, q: ⇒ Boolean): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
option[A](cond: Boolean, a: ⇒ A): Option[A]
-
implicit
def
optionEqual[A](implicit A0: Equal[A]): Equal[Option[A]]
-
-
implicit
def
optionFirstMonad: Monad[FirstOption]
-
implicit
def
optionFirstOrder[A](implicit arg0: Order[A]): Order[FirstOption[A]]
-
implicit
def
optionFirstShow[A](implicit arg0: Show[A]): Show[FirstOption[A]]
-
implicit
val
optionInstance: Traverse[Option] with MonadPlus[Option] with Each[Option] with Index[Option] with Length[Option] with Cozip[Option] with Zip[Option] with Unzip[Option] with Align[Option] with IsEmpty[Option] with Cobind[Option] with Optional[Option] { ... /* 2 definitions in type refinement */ }
-
implicit
def
optionLast[A]: Monoid[LastOption[A]]
-
implicit
def
optionLastMonad: Monad[LastOption]
-
implicit
def
optionLastOrder[A](implicit arg0: Order[A]): Order[LastOption[A]]
-
implicit
def
optionLastShow[A](implicit arg0: Show[A]): Show[LastOption[A]]
-
implicit
def
optionMax[A](implicit o: Order[A]): Monoid[MaxOption[A]]
-
implicit
def
optionMaxMonad: Monad[MaxOption]
-
implicit
def
optionMaxOrder[A](implicit arg0: Order[A]): Order[MaxOption[A]]
-
implicit
def
optionMaxShow[A](implicit arg0: Show[A]): Show[MaxOption[A]]
-
implicit
def
optionMin[A](implicit o: Order[A]): Monoid[MinOption[A]]
-
implicit
def
optionMinMonad: Monad[MinOption]
-
implicit
def
optionMinOrder[A](implicit arg0: Order[A]): Order[MinOption[A]]
-
implicit
def
optionMinShow[A](implicit arg0: Show[A]): Show[MinOption[A]]
-
implicit
def
optionMonoid[A](implicit arg0: Semigroup[A]): Monoid[Option[A]]
-
implicit
def
optionOrder[A](implicit A0: Order[A]): Order[Option[A]]
-
implicit
def
optionShow[A](implicit arg0: Show[A]): Show[Option[A]]
-
final
def
orEmpty[A, M[_]](oa: Option[A])(implicit arg0: Applicative[M], arg1: PlusEmpty[M]): M[A]
-
def
orderingMonoid[A]: Monoid[scala.math.Ordering[A]]
-
def
parseBoolean(s: String): Validation[IllegalArgumentException, Boolean]
-
def
parseByte(s: String): Validation[NumberFormatException, Byte]
-
def
parseDouble(s: String): Validation[NumberFormatException, Double]
-
def
parseFloat(s: String): Validation[NumberFormatException, Float]
-
def
parseInt(s: String): Validation[NumberFormatException, Int]
-
def
parseLong(s: String): Validation[NumberFormatException, Long]
-
def
parseShort(s: String): Validation[NumberFormatException, Short]
-
def
parserMonad[P <: Parsers](p: P): Monad[[A]std.util.parsing.combinator.Parsers.parserMonad.P.Parser[A]] forSome {val _2025: ParsersW[P]}
-
implicit
val
partialFunctionInstance: Arrow[PartialFunction] with Category[PartialFunction] with Choice[PartialFunction]
-
final
def
partitionM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit F: Applicative[M]): M[(List[A], List[A])]
-
def
plural(s: String, n: Long): String
-
final
def
pointOrEmpty[M[_], A](cond: Boolean)(a: ⇒ A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A]
-
final
def
pointOrEmptyNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): ~>[Id.Id, M]
-
final
def
powerset[A](as: List[A]): List[List[A]]
-
def
put[S](s: S): State[S, Unit]
-
implicit
val
setInstance: Foldable[Set] with IsEmpty[Set] with Length[Set]
-
implicit
def
setMonoid[A]: Monoid[Set[A]]
-
implicit
def
setOrder[A](implicit arg0: Order[A]): Order[Set[A]]
-
implicit
def
setShow[A](implicit arg0: Show[A]): Show[Set[A]]
-
implicit
val
shortInstance: Monoid[Short] with Enum[Short] with Show[Short]
-
-
final
def
some[A](a: A): Option[A]
-
final
def
spanM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]
-
def
state[S, A](a: A): State[S, A]
-
implicit
def
streamEqual[A](implicit A0: Equal[A]): Equal[Stream[A]]
-
implicit
val
streamInstance: Traverse[Stream] with MonadPlus[Stream] with Each[Stream] with Index[Stream] with Length[Stream] with Zip[Stream] with Unzip[Stream] with Align[Stream] with IsEmpty[Stream] with Cobind[Stream]
-
implicit
def
streamMonoid[A]: Monoid[Stream[A]]
-
implicit
def
streamShow[A](implicit A0: Show[A]): Show[Stream[A]]
-
implicit
val
streamZipApplicative: Applicative[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
-
implicit
object
stringInstance extends Monoid[String] with Show[String] with Equal[String] with Order[String] with IsEmpty[[α]String]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
final
def
tailOption[A](as: List[A]): Option[List[A]]
-
final
def
tails[A](as: Stream[A]): Stream[Stream[A]]
-
final
def
tailz[A](as: List[A]): List[List[A]]
-
final
def
takeUntilM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]
-
final
def
takeWhileM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]
-
def
test(p: Boolean): Int
-
final
def
toFailure[A, B](oa: Option[A])(b: ⇒ B): Validation[A, B]
-
final
def
toLeft[A, B](oa: Option[A])(b: ⇒ B): \/[A, B]
-
final
def
toMaybe[A](oa: Option[A]): Maybe[A]
-
final
def
toNel[A](as: List[A]): Option[NonEmptyList[A]]
-
final
def
toRight[A, E](oa: Option[A])(e: ⇒ E): \/[E, A]
-
def
toString(): String
-
final
def
toSuccess[A, E](oa: Option[A])(e: ⇒ E): Validation[E, A]
-
final
def
toZipper[A](as: Stream[A]): Option[Zipper[A]]
-
final
def
toZipper[A](as: List[A]): Option[Zipper[A]]
-
implicit
val
tuple1Cozip: Cozip[Tuple1]
-
implicit
def
tuple1Equal[A1](implicit A1: Equal[A1]): Equal[(A1)]
-
implicit
val
tuple1Instance: Traverse[Tuple1] with Monad[Tuple1] with Comonad[Tuple1]
-
implicit
def
tuple1Monoid[A1](implicit A1: Monoid[A1]): Monoid[(A1)]
-
implicit
def
tuple1Order[A1](implicit A1: Order[A1]): Order[(A1)]
-
implicit
def
tuple1Semigroup[A1](implicit A1: Semigroup[A1]): Semigroup[(A1)]
-
implicit
def
tuple1Show[A1](implicit A1: Show[A1]): Show[(A1)]
-
implicit
val
tuple2Bitraverse: Bitraverse[Tuple2]
-
implicit
def
tuple2Cozip[A1]: Cozip[[x](A1, x)]
-
implicit
def
tuple2Equal[A1, A2](implicit A1: Equal[A1], A2: Equal[A2]): Equal[(A1, A2)]
-
implicit
def
tuple2Instance[A1]: Traverse[[x](A1, x)] with Comonad[[x](A1, x)]
-
implicit
def
tuple2Monad[A1](implicit A1: Monoid[A1]): Monad[[x](A1, x)]
-
implicit
def
tuple2Monoid[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monoid[(A1, A2)]
-
implicit
def
tuple2Order[A1, A2](implicit A1: Order[A1], A2: Order[A2]): Order[(A1, A2)]
-
implicit
def
tuple2Semigroup[A1, A2](implicit A1: Semigroup[A1], A2: Semigroup[A2]): Semigroup[(A1, A2)]
-
implicit
def
tuple2Show[A1, A2](implicit A1: Show[A1], A2: Show[A2]): Show[(A1, A2)]
-
implicit
def
tuple3Cozip[A1, A2]: Cozip[[x](A1, A2, x)]
-
implicit
def
tuple3Equal[A1, A2, A3](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3]): Equal[(A1, A2, A3)]
-
implicit
def
tuple3Functor[A1, A2]: Traverse[[x](A1, A2, x)]
-
implicit
def
tuple3Monad[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monad[[x](A1, A2, x)]
-
implicit
def
tuple3Monoid[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monoid[(A1, A2, A3)]
-
implicit
def
tuple3Order[A1, A2, A3](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3]): Order[(A1, A2, A3)]
-
implicit
def
tuple3Semigroup[A1, A2, A3](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3]): Semigroup[(A1, A2, A3)]
-
implicit
def
tuple3Show[A1, A2, A3](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3]): Show[(A1, A2, A3)]
-
implicit
def
tuple4Cozip[A1, A2, A3]: Cozip[[x](A1, A2, A3, x)]
-
implicit
def
tuple4Equal[A1, A2, A3, A4](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4]): Equal[(A1, A2, A3, A4)]
-
implicit
def
tuple4Functor[A1, A2, A3]: Traverse[[x](A1, A2, A3, x)]
-
implicit
def
tuple4Monad[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monad[[x](A1, A2, A3, x)]
-
implicit
def
tuple4Monoid[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monoid[(A1, A2, A3, A4)]
-
implicit
def
tuple4Order[A1, A2, A3, A4](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4]): Order[(A1, A2, A3, A4)]
-
implicit
def
tuple4Semigroup[A1, A2, A3, A4](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4]): Semigroup[(A1, A2, A3, A4)]
-
implicit
def
tuple4Show[A1, A2, A3, A4](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4]): Show[(A1, A2, A3, A4)]
-
implicit
def
tuple5Cozip[A1, A2, A3, A4]: Cozip[[x](A1, A2, A3, A4, x)]
-
implicit
def
tuple5Equal[A1, A2, A3, A4, A5](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5]): Equal[(A1, A2, A3, A4, A5)]
-
implicit
def
tuple5Functor[A1, A2, A3, A4]: Traverse[[x](A1, A2, A3, A4, x)]
-
implicit
def
tuple5Monad[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monad[[x](A1, A2, A3, A4, x)]
-
implicit
def
tuple5Monoid[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monoid[(A1, A2, A3, A4, A5)]
-
implicit
def
tuple5Order[A1, A2, A3, A4, A5](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5]): Order[(A1, A2, A3, A4, A5)]
-
implicit
def
tuple5Semigroup[A1, A2, A3, A4, A5](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5]): Semigroup[(A1, A2, A3, A4, A5)]
-
implicit
def
tuple5Show[A1, A2, A3, A4, A5](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5]): Show[(A1, A2, A3, A4, A5)]
-
implicit
def
tuple6Cozip[A1, A2, A3, A4, A5]: Cozip[[x](A1, A2, A3, A4, A5, x)]
-
implicit
def
tuple6Equal[A1, A2, A3, A4, A5, A6](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6]): Equal[(A1, A2, A3, A4, A5, A6)]
-
implicit
def
tuple6Functor[A1, A2, A3, A4, A5]: Traverse[[x](A1, A2, A3, A4, A5, x)]
-
implicit
def
tuple6Monad[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monad[[x](A1, A2, A3, A4, A5, x)]
-
implicit
def
tuple6Monoid[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monoid[(A1, A2, A3, A4, A5, A6)]
-
implicit
def
tuple6Order[A1, A2, A3, A4, A5, A6](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6]): Order[(A1, A2, A3, A4, A5, A6)]
-
implicit
def
tuple6Semigroup[A1, A2, A3, A4, A5, A6](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6]): Semigroup[(A1, A2, A3, A4, A5, A6)]
-
implicit
def
tuple6Show[A1, A2, A3, A4, A5, A6](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6]): Show[(A1, A2, A3, A4, A5, A6)]
-
implicit
def
tuple7Cozip[A1, A2, A3, A4, A5, A6]: Cozip[[x](A1, A2, A3, A4, A5, A6, x)]
-
implicit
def
tuple7Equal[A1, A2, A3, A4, A5, A6, A7](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7]): Equal[(A1, A2, A3, A4, A5, A6, A7)]
-
implicit
def
tuple7Functor[A1, A2, A3, A4, A5, A6]: Traverse[[x](A1, A2, A3, A4, A5, A6, x)]
-
implicit
def
tuple7Monad[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monad[[x](A1, A2, A3, A4, A5, A6, x)]
-
implicit
def
tuple7Monoid[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monoid[(A1, A2, A3, A4, A5, A6, A7)]
-
implicit
def
tuple7Order[A1, A2, A3, A4, A5, A6, A7](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7]): Order[(A1, A2, A3, A4, A5, A6, A7)]
-
implicit
def
tuple7Semigroup[A1, A2, A3, A4, A5, A6, A7](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7]): Semigroup[(A1, A2, A3, A4, A5, A6, A7)]
-
implicit
def
tuple7Show[A1, A2, A3, A4, A5, A6, A7](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7]): Show[(A1, A2, A3, A4, A5, A6, A7)]
-
implicit
def
tuple8Cozip[A1, A2, A3, A4, A5, A6, A7]: Cozip[[x](A1, A2, A3, A4, A5, A6, A7, x)]
-
implicit
def
tuple8Equal[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7], A8: Equal[A8]): Equal[(A1, A2, A3, A4, A5, A6, A7, A8)]
-
implicit
def
tuple8Functor[A1, A2, A3, A4, A5, A6, A7]: Traverse[[x](A1, A2, A3, A4, A5, A6, A7, x)]
-
implicit
def
tuple8Monad[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monad[[x](A1, A2, A3, A4, A5, A6, A7, x)]
-
implicit
def
tuple8Monoid[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7], A8: Monoid[A8]): Monoid[(A1, A2, A3, A4, A5, A6, A7, A8)]
-
implicit
def
tuple8Order[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7], A8: Order[A8]): Order[(A1, A2, A3, A4, A5, A6, A7, A8)]
-
implicit
def
tuple8Semigroup[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7], A8: Semigroup[A8]): Semigroup[(A1, A2, A3, A4, A5, A6, A7, A8)]
-
implicit
def
tuple8Show[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7], A8: Show[A8]): Show[(A1, A2, A3, A4, A5, A6, A7, A8)]
-
def
unfold[A, B](seed: A)(f: (A) ⇒ Option[(B, A)]): Stream[B]
-
final
def
unfoldForest[A, B](as: Stream[A])(f: (A) ⇒ (B, () ⇒ Stream[A])): Stream[Tree[B]]
-
final
def
unfoldForestM[A, B, M[_]](as: Stream[A])(f: (A) ⇒ M[(B, Stream[A])])(implicit arg0: Monad[M]): M[Stream[Tree[B]]]
-
final
def
unionWith[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
-
final
def
unionWithKey[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (K, A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
-
implicit
val
unitInstance: Monoid[Unit] with Enum[Unit] with Show[Unit]
-
final
def
unless(cond: Boolean)(f: ⇒ Unit): Unit
-
final
def
unlessM[M[_], A](cond: Boolean)(f: ⇒ M[A])(implicit M: Applicative[M]): M[Unit]
-
def
unsafeCharsNel(s: String): NonEmptyList[Char]
-
final
def
valueOrZero[A](cond: Boolean)(value: ⇒ A)(implicit z: Monoid[A]): A
-
implicit
def
vectorEqual[A](implicit A0: Equal[A]): Equal[Vector[A]]
-
-
implicit
def
vectorMonoid[A]: Monoid[Vector[A]]
-
implicit
def
vectorOrder[A](implicit A0: Order[A]): Order[Vector[A]]
-
implicit
def
vectorShow[A](implicit arg0: Show[A]): Show[Vector[A]]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
when(cond: Boolean)(f: ⇒ Unit): Unit
-
final
def
whenM[M[_], A](cond: Boolean)(f: ⇒ M[A])(implicit M: Applicative[M]): M[Unit]
-
final
def
zapp[A, B, C](a: Stream[A])(f: Stream[(A) ⇒ (B) ⇒ C]): Stream[(B) ⇒ C]
-
final
def
zeroOrValue[A](cond: Boolean)(value: ⇒ A)(implicit z: Monoid[A]): A
-
final
def
zipperEnd[A](as: Stream[A]): Option[Zipper[A]]
-
final
def
zipperEnd[A](as: List[A]): Option[Zipper[A]]
-
def
∅[F](implicit F: Monoid[F]): F
Deprecated Value Members
-
final
def
groupByM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[NonEmptyList[A]]]
-
implicit
val
intMetricSpace: MetricSpace[Int]
-
final
def
merge[A](s1: Stream[A], s2: Stream[A]): Stream[A]
Inherited from AnyRef
Inherited from Any
