implicit object PotCats extends MonadError[Pot, Throwable] with Traverse[Pot] with Align[Pot]
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- PotCats
- Align
- Traverse
- UnorderedTraverse
- Foldable
- FoldableNFunctions
- UnorderedFoldable
- MonadError
- Monad
- FlatMap
- FlatMapArityFunctions
- ApplicativeError
- Applicative
- InvariantMonoidal
- Apply
- ApplyArityFunctions
- InvariantSemigroupal
- Semigroupal
- Functor
- Invariant
- Serializable
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def *>[A, B](fa: Pot[A])(fb: Pot[B]): Pot[B]
- Definition Classes
- Apply
- Annotations
- @inline()
- final def <*[A, B](fa: Pot[A])(fb: Pot[B]): Pot[A]
- Definition Classes
- Apply
- Annotations
- @inline()
- final def <*>[A, B](ff: Pot[(A) => B])(fa: Pot[A]): Pot[B]
- Definition Classes
- Apply
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def adaptError[A](fa: Pot[A])(pf: PartialFunction[Throwable, Throwable]): Pot[A]
- Definition Classes
- MonadError → ApplicativeError
- def align[A, B](fa: Pot[A], fb: Pot[B]): Pot[Ior[A, B]]
- Definition Classes
- PotCats → Align
- def alignCombine[A](fa1: Pot[A], fa2: Pot[A])(implicit arg0: Semigroup[A]): Pot[A]
- Definition Classes
- Align
- def alignMergeWith[A](fa1: Pot[A], fa2: Pot[A])(f: (A, A) => A): Pot[A]
- Definition Classes
- Align
- def alignWith[A, B, C](fa: Pot[A], fb: Pot[B])(f: (Ior[A, B]) => C): Pot[C]
- Definition Classes
- PotCats → Align
- def ap[A, B](ff: Pot[(A) => B])(fa: Pot[A]): Pot[B]
- Definition Classes
- FlatMap → Apply
- def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap2[A, B, Z](ff: Pot[(A, B) => Z])(fa: Pot[A], fb: Pot[B]): Pot[Z]
- Definition Classes
- FlatMap → Apply
- def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20], f21: Pot[A21]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap3[A0, A1, A2, Z](f: Pot[(A0, A1, A2) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap4[A0, A1, A2, A3, Z](f: Pot[(A0, A1, A2, A3) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap5[A0, A1, A2, A3, A4, Z](f: Pot[(A0, A1, A2, A3, A4) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap6[A0, A1, A2, A3, A4, A5, Z](f: Pot[(A0, A1, A2, A3, A4, A5) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8]): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def as[A, B](fa: Pot[A], b: B): Pot[B]
- Definition Classes
- Functor
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attempt[A](fa: Pot[A]): Pot[Either[Throwable, A]]
- Definition Classes
- ApplicativeError
- def attemptNarrow[EE <: Throwable, A](fa: Pot[A])(implicit tag: ClassTag[EE], ev: <:<[EE, Throwable]): Pot[Either[EE, A]]
- Definition Classes
- ApplicativeError
- def attemptT[A](fa: Pot[A]): EitherT[Pot, Throwable, A]
- Definition Classes
- ApplicativeError
- def attemptTap[A, B](fa: Pot[A])(f: (Either[Throwable, A]) => Pot[B]): Pot[A]
- Definition Classes
- MonadError
- def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, Throwable]): Pot[A]
- Definition Classes
- ApplicativeError
- def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, Throwable]): Pot[A]
- Definition Classes
- ApplicativeError
- def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, Pot, Throwable]
- Definition Classes
- ApplicativeError
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def collectFirst[A, B](fa: Pot[A])(pf: PartialFunction[A, B]): Option[B]
- Definition Classes
- Foldable
- def collectFirstSome[A, B](fa: Pot[A])(f: (A) => Option[B]): Option[B]
- Definition Classes
- Foldable
- def collectFirstSomeM[G[_], A, B](fa: Pot[A])(f: (A) => G[Option[B]])(implicit G: Monad[G]): G[Option[B]]
- Definition Classes
- Foldable
- def collectFold[A, B](fa: Pot[A])(f: PartialFunction[A, B])(implicit B: Monoid[B]): B
- Definition Classes
- Foldable
- def collectFoldSome[A, B](fa: Pot[A])(f: (A) => Option[B])(implicit B: Monoid[B]): B
- Definition Classes
- Foldable
- def combineAll[A](fa: Pot[A])(implicit arg0: Monoid[A]): A
- Definition Classes
- Foldable
- def combineAllOption[A](fa: Pot[A])(implicit ev: Semigroup[A]): Option[A]
- Definition Classes
- Foldable
- def compose[G[_]](implicit arg0: Traverse[G]): Traverse[[α]Pot[G[α]]]
- Definition Classes
- Traverse
- def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]Pot[G[α]]]
- Definition Classes
- Foldable
- def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]Pot[G[α]]]
- Definition Classes
- Applicative
- def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]Pot[G[α]]]
- Definition Classes
- Apply
- def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]Pot[G[α]]]
- Definition Classes
- Functor
- def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]Pot[G[α]]]
- Definition Classes
- Invariant
- def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]Pot[G[α]]]
- Definition Classes
- InvariantSemigroupal
- def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]Pot[G[α]]]
- Definition Classes
- Functor → Invariant
- def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]Pot[G[α]]]
- Definition Classes
- Applicative
- def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]Pot[G[α]]]
- Definition Classes
- Invariant
- def contains_[A](fa: Pot[A], v: A)(implicit ev: Eq[A]): Boolean
- Definition Classes
- UnorderedFoldable
- def count[A](fa: Pot[A])(p: (A) => Boolean): Long
- Definition Classes
- UnorderedFoldable
- def dropWhile_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
- Definition Classes
- Foldable
- def ensure[A](fa: Pot[A])(error: => Throwable)(predicate: (A) => Boolean): Pot[A]
- Definition Classes
- MonadError
- def ensureOr[A](fa: Pot[A])(error: (A) => Throwable)(predicate: (A) => Boolean): Pot[A]
- Definition Classes
- MonadError
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def exists[A](fa: Pot[A])(p: (A) => Boolean): Boolean
- Definition Classes
- Foldable → UnorderedFoldable
- def existsM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
- Definition Classes
- Foldable
- def filter_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
- Definition Classes
- Foldable
- def find[A](fa: Pot[A])(f: (A) => Boolean): Option[A]
- Definition Classes
- Foldable
- def findM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Option[A]]
- Definition Classes
- Foldable
- def flatMap[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[B]
- Definition Classes
- PotCats → FlatMap
- def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap2[A0, A1, Z](f0: Pot[A0], f1: Pot[A1])(f: (A0, A1) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20], f21: Pot[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap3[A0, A1, A2, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2])(f: (A0, A1, A2) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap4[A0, A1, A2, A3, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3])(f: (A0, A1, A2, A3) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap5[A0, A1, A2, A3, A4, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4])(f: (A0, A1, A2, A3, A4) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5])(f: (A0, A1, A2, A3, A4, A5) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Pot[Z]): Pot[Z]
- Definition Classes
- FlatMapArityFunctions
- def flatSequence[G[_], A](fgfa: Pot[G[Pot[A]]])(implicit G: Applicative[G], F: FlatMap[Pot]): G[Pot[A]]
- Definition Classes
- Traverse
- def flatTap[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[A]
- Definition Classes
- FlatMap
- def flatTraverse[G[_], A, B](fa: Pot[A])(f: (A) => G[Pot[B]])(implicit G: Applicative[G], F: FlatMap[Pot]): G[Pot[B]]
- Definition Classes
- Traverse
- def flatten[A](ffa: Pot[Pot[A]]): Pot[A]
- Definition Classes
- FlatMap
- final def fmap[A, B](fa: Pot[A])(f: (A) => B): Pot[B]
- Definition Classes
- Functor
- def fold[A](fa: Pot[A])(implicit A: Monoid[A]): A
- Definition Classes
- Foldable
- def foldA[G[_], A](fga: Pot[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A]
- Definition Classes
- Foldable
- def foldK[G[_], A](fga: Pot[G[A]])(implicit G: MonoidK[G]): G[A]
- Definition Classes
- Foldable
- def foldLeft[A, B](fa: Pot[A], b: B)(f: (B, A) => B): B
- Definition Classes
- PotCats → Foldable
- final def foldLeftM[G[_], A, B](fa: Pot[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
- Definition Classes
- Foldable
- def foldM[G[_], A, B](fa: Pot[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
- Definition Classes
- Foldable
- def foldMap[A, B](fa: Pot[A])(f: (A) => B)(implicit B: Monoid[B]): B
- Definition Classes
- Foldable
- def foldMapA[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]
- Definition Classes
- Foldable
- def foldMapK[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: MonoidK[G]): G[B]
- Definition Classes
- Foldable
- def foldMapM[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]
- Definition Classes
- Foldable
- def foldRight[A, B](fa: Pot[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]
- Definition Classes
- PotCats → Foldable
- def foldRightDefer[G[_], A, B](fa: Pot[A], gb: G[B])(fn: (A, G[B]) => G[B])(implicit arg0: Defer[G]): G[B]
- Definition Classes
- Foldable
- def forall[A](fa: Pot[A])(p: (A) => Boolean): Boolean
- Definition Classes
- Foldable → UnorderedFoldable
- def forallM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
- Definition Classes
- Foldable
- def foreverM[A, B](fa: Pot[A]): Pot[B]
- Definition Classes
- FlatMap
- def fproduct[A, B](fa: Pot[A])(f: (A) => B): Pot[(A, B)]
- Definition Classes
- Functor
- def fproductLeft[A, B](fa: Pot[A])(f: (A) => B): Pot[(B, A)]
- Definition Classes
- Functor
- def fromEither[A](x: Either[Throwable, A]): Pot[A]
- Definition Classes
- ApplicativeError
- def fromOption[A](oa: Option[A], ifEmpty: => Throwable): Pot[A]
- Definition Classes
- ApplicativeError
- def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, Throwable]): Pot[A]
- Definition Classes
- ApplicativeError
- def fromValidated[A](x: Validated[Throwable, A]): Pot[A]
- Definition Classes
- ApplicativeError
- def functor: Functor[Pot]
- Definition Classes
- PotCats → Align
- def get[A](fa: Pot[A])(idx: Long): Option[A]
- Definition Classes
- Foldable
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def handleError[A](fa: Pot[A])(f: (Throwable) => A): Pot[A]
- Definition Classes
- ApplicativeError
- def handleErrorWith[A](fa: Pot[A])(f: (Throwable) => Pot[A]): Pot[A]
- Definition Classes
- PotCats → ApplicativeError
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def ifElseM[A](branches: (Pot[Boolean], Pot[A])*)(els: Pot[A]): Pot[A]
- Definition Classes
- Monad
- def ifF[A](fb: Pot[Boolean])(ifTrue: => A, ifFalse: => A): Pot[A]
- Definition Classes
- Functor
- def ifM[B](fa: Pot[Boolean])(ifTrue: => Pot[B], ifFalse: => Pot[B]): Pot[B]
- Definition Classes
- FlatMap
- def imap[A, B](fa: Pot[A])(f: (A) => B)(g: (B) => A): Pot[B]
- Definition Classes
- Functor → Invariant
- def intercalate[A](fa: Pot[A], a: A)(implicit A: Monoid[A]): A
- Definition Classes
- Foldable
- def intersperseList[A](xs: List[A], x: A): List[A]
- Attributes
- protected
- Definition Classes
- Foldable
- def isEmpty[A](fa: Pot[A]): Boolean
- Definition Classes
- Foldable → UnorderedFoldable
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterateForeverM[A, B](a: A)(f: (A) => Pot[A]): Pot[B]
- Definition Classes
- FlatMap
- def iterateUntil[A](f: Pot[A])(p: (A) => Boolean): Pot[A]
- Definition Classes
- Monad
- def iterateUntilM[A](init: A)(f: (A) => Pot[A])(p: (A) => Boolean): Pot[A]
- Definition Classes
- Monad
- def iterateWhile[A](f: Pot[A])(p: (A) => Boolean): Pot[A]
- Definition Classes
- Monad
- def iterateWhileM[A](init: A)(f: (A) => Pot[A])(p: (A) => Boolean): Pot[A]
- Definition Classes
- Monad
- def lift[A, B](f: (A) => B): (Pot[A]) => Pot[B]
- Definition Classes
- Functor
- def map[A, B](fa: Pot[A])(f: (A) => B): Pot[B]
- Definition Classes
- Traverse → Functor
- def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map2[A, B, Z](fa: Pot[A], fb: Pot[B])(f: (A, B) => Z): Pot[Z]
- Definition Classes
- FlatMap → Apply
- def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20], f21: Pot[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map2Eval[A, B, Z](fa: Pot[A], fb: Eval[Pot[B]])(f: (A, B) => Z): Eval[Pot[Z]]
- Definition Classes
- FlatMap → Apply
- def map3[A0, A1, A2, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2])(f: (A0, A1, A2) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map4[A0, A1, A2, A3, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3])(f: (A0, A1, A2, A3) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map5[A0, A1, A2, A3, A4, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4])(f: (A0, A1, A2, A3, A4) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map6[A0, A1, A2, A3, A4, A5, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): Pot[Z]
- Definition Classes
- ApplyArityFunctions
- def mapAccumulate[S, A, B](init: S, fa: Pot[A])(f: (S, A) => (S, B)): (S, Pot[B])
- Definition Classes
- Traverse
- def mapWithIndex[A, B](fa: Pot[A])(f: (A, Int) => B): Pot[B]
- Definition Classes
- Traverse
- def maximumByList[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): List[A]
- Definition Classes
- Foldable
- def maximumByOption[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
- Definition Classes
- Foldable
- def maximumList[A](fa: Pot[A])(implicit A: Order[A]): List[A]
- Definition Classes
- Foldable
- def maximumOption[A](fa: Pot[A])(implicit A: Order[A]): Option[A]
- Definition Classes
- Foldable
- def minimumByList[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): List[A]
- Definition Classes
- Foldable
- def minimumByOption[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
- Definition Classes
- Foldable
- def minimumList[A](fa: Pot[A])(implicit A: Order[A]): List[A]
- Definition Classes
- Foldable
- def minimumOption[A](fa: Pot[A])(implicit A: Order[A]): Option[A]
- Definition Classes
- Foldable
- def mproduct[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[(A, B)]
- Definition Classes
- FlatMap
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmpty[A](fa: Pot[A]): Boolean
- Definition Classes
- Foldable → UnorderedFoldable
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def onError[A](fa: Pot[A])(pf: PartialFunction[Throwable, Pot[Unit]]): Pot[A]
- Definition Classes
- ApplicativeError
- def padZip[A, B](fa: Pot[A], fb: Pot[B]): Pot[(Option[A], Option[B])]
- Definition Classes
- Align
- def padZipWith[A, B, C](fa: Pot[A], fb: Pot[B])(f: (Option[A], Option[B]) => C): Pot[C]
- Definition Classes
- Align
- def partitionBifold[H[_, _], A, B, C](fa: Pot[A])(f: (A) => H[B, C])(implicit A: Alternative[Pot], H: Bifoldable[H]): (Pot[B], Pot[C])
- Definition Classes
- Foldable
- def partitionBifoldM[G[_], H[_, _], A, B, C](fa: Pot[A])(f: (A) => G[H[B, C]])(implicit A: Alternative[Pot], M: Monad[G], H: Bifoldable[H]): G[(Pot[B], Pot[C])]
- Definition Classes
- Foldable
- def partitionEither[A, B, C](fa: Pot[A])(f: (A) => Either[B, C])(implicit A: Alternative[Pot]): (Pot[B], Pot[C])
- Definition Classes
- Foldable
- def partitionEitherM[G[_], A, B, C](fa: Pot[A])(f: (A) => G[Either[B, C]])(implicit A: Alternative[Pot], M: Monad[G]): G[(Pot[B], Pot[C])]
- Definition Classes
- Foldable
- def point[A](a: A): Pot[A]
- Definition Classes
- InvariantMonoidal
- def product[A, B](fa: Pot[A], fb: Pot[B]): Pot[(A, B)]
- Definition Classes
- FlatMap → Apply → Semigroupal
- def productAll[A](fa: Pot[A])(implicit A: Numeric[A]): A
- Definition Classes
- Foldable
- def productL[A, B](fa: Pot[A])(fb: Pot[B]): Pot[A]
- Definition Classes
- FlatMap → Apply
- def productLEval[A, B](fa: Pot[A])(fb: Eval[Pot[B]]): Pot[A]
- Definition Classes
- FlatMap
- def productR[A, B](fa: Pot[A])(fb: Pot[B]): Pot[B]
- Definition Classes
- FlatMap → Apply
- def productREval[A, B](fa: Pot[A])(fb: Eval[Pot[B]]): Pot[B]
- Definition Classes
- FlatMap
- def pure[A](a: A): Pot[A]
- Definition Classes
- PotCats → Applicative
- def raiseError[A](t: Throwable): Pot[A]
- Definition Classes
- PotCats → ApplicativeError
- def raiseUnless(cond: Boolean)(e: => Throwable): Pot[Unit]
- Definition Classes
- ApplicativeError
- def raiseWhen(cond: Boolean)(e: => Throwable): Pot[Unit]
- Definition Classes
- ApplicativeError
- def recover[A](fa: Pot[A])(pf: PartialFunction[Throwable, A]): Pot[A]
- Definition Classes
- ApplicativeError
- def recoverWith[A](fa: Pot[A])(pf: PartialFunction[Throwable, Pot[A]]): Pot[A]
- Definition Classes
- ApplicativeError
- def redeem[A, B](fa: Pot[A])(recover: (Throwable) => B, f: (A) => B): Pot[B]
- Definition Classes
- ApplicativeError
- def redeemWith[A, B](fa: Pot[A])(recover: (Throwable) => Pot[B], bind: (A) => Pot[B]): Pot[B]
- Definition Classes
- MonadError
- def reduceLeftOption[A](fa: Pot[A])(f: (A, A) => A): Option[A]
- Definition Classes
- Foldable
- def reduceLeftToOption[A, B](fa: Pot[A])(f: (A) => B)(g: (B, A) => B): Option[B]
- Definition Classes
- Foldable
- def reduceRightOption[A](fa: Pot[A])(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]]
- Definition Classes
- Foldable
- def reduceRightToOption[A, B](fa: Pot[A])(f: (A) => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]
- Definition Classes
- Foldable
- def replicateA[A](n: Int, fa: Pot[A]): Pot[List[A]]
- Definition Classes
- Applicative
- def replicateA_[A](n: Int, fa: Pot[A]): Pot[Unit]
- Definition Classes
- Applicative
- def rethrow[A, EE <: Throwable](fa: Pot[Either[EE, A]]): Pot[A]
- Definition Classes
- MonadError
- def sequence[G[_], A](fga: Pot[G[A]])(implicit arg0: Applicative[G]): G[Pot[A]]
- Definition Classes
- Traverse
- def sequence_[G[_], A](fga: Pot[G[A]])(implicit arg0: Applicative[G]): G[Unit]
- Definition Classes
- Foldable
- def size[A](fa: Pot[A]): Long
- Definition Classes
- UnorderedFoldable
- def sliding10[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding11[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding12[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding13[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding14[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding15[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding16[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding17[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding18[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding19[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding2[A](fa: Pot[A]): List[(A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding20[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding21[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding22[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding3[A](fa: Pot[A]): List[(A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding4[A](fa: Pot[A]): List[(A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding5[A](fa: Pot[A]): List[(A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding6[A](fa: Pot[A]): List[(A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding7[A](fa: Pot[A]): List[(A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding8[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding9[A](fa: Pot[A]): List[(A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sumAll[A](fa: Pot[A])(implicit A: Numeric[A]): A
- Definition Classes
- Foldable
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tailRecM[A, B](a: A)(f: (A) => Pot[Either[A, B]]): Pot[B]
- Definition Classes
- PotCats → FlatMap
- Annotations
- @tailrec()
- def takeWhile_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
- Definition Classes
- Foldable
- def toIterable[A](fa: Pot[A]): Iterable[A]
- Definition Classes
- Foldable
- def toList[A](fa: Pot[A]): List[A]
- Definition Classes
- Foldable
- def toString(): String
- Definition Classes
- AnyRef → Any
- def traverse[F[_], A, B](fa: Pot[A])(f: (A) => F[B])(implicit F: Applicative[F]): F[Pot[B]]
- Definition Classes
- PotCats → Traverse
- def traverseTap[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit arg0: Applicative[G]): G[Pot[A]]
- Definition Classes
- Traverse
- def traverseWithIndexM[G[_], A, B](fa: Pot[A])(f: (A, Int) => G[B])(implicit G: Monad[G]): G[Pot[B]]
- Definition Classes
- Traverse
- def traverse_[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Applicative[G]): G[Unit]
- Definition Classes
- Foldable
- def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
- Definition Classes
- ApplyArityFunctions
- def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
- Definition Classes
- ApplyArityFunctions
- def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
- Definition Classes
- ApplyArityFunctions
- def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
- Definition Classes
- ApplyArityFunctions
- def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
- Definition Classes
- ApplyArityFunctions
- def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
- Definition Classes
- ApplyArityFunctions
- def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
- Definition Classes
- ApplyArityFunctions
- def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
- Definition Classes
- ApplyArityFunctions
- def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
- Definition Classes
- ApplyArityFunctions
- def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
- Definition Classes
- ApplyArityFunctions
- def tuple2[A, B](f1: Pot[A], f2: Pot[B]): Pot[(A, B)]
- Definition Classes
- ApplyArityFunctions
- def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
- Definition Classes
- ApplyArityFunctions
- def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
- Definition Classes
- ApplyArityFunctions
- def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8], f9: Pot[A9], f10: Pot[A10], f11: Pot[A11], f12: Pot[A12], f13: Pot[A13], f14: Pot[A14], f15: Pot[A15], f16: Pot[A16], f17: Pot[A17], f18: Pot[A18], f19: Pot[A19], f20: Pot[A20], f21: Pot[A21]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
- Definition Classes
- ApplyArityFunctions
- def tuple3[A0, A1, A2](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2]): Pot[(A0, A1, A2)]
- Definition Classes
- ApplyArityFunctions
- def tuple4[A0, A1, A2, A3](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3]): Pot[(A0, A1, A2, A3)]
- Definition Classes
- ApplyArityFunctions
- def tuple5[A0, A1, A2, A3, A4](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4]): Pot[(A0, A1, A2, A3, A4)]
- Definition Classes
- ApplyArityFunctions
- def tuple6[A0, A1, A2, A3, A4, A5](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5]): Pot[(A0, A1, A2, A3, A4, A5)]
- Definition Classes
- ApplyArityFunctions
- def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6]): Pot[(A0, A1, A2, A3, A4, A5, A6)]
- Definition Classes
- ApplyArityFunctions
- def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7)]
- Definition Classes
- ApplyArityFunctions
- def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4], f5: Pot[A5], f6: Pot[A6], f7: Pot[A7], f8: Pot[A8]): Pot[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
- Definition Classes
- ApplyArityFunctions
- def tupleLeft[A, B](fa: Pot[A], b: B): Pot[(B, A)]
- Definition Classes
- Functor
- def tupleRight[A, B](fa: Pot[A], b: B): Pot[(A, B)]
- Definition Classes
- Functor
- def unit: Pot[Unit]
- Definition Classes
- Applicative → InvariantMonoidal
- def unlessA[A](cond: Boolean)(f: => Pot[A]): Pot[Unit]
- Definition Classes
- Applicative
- def unorderedFold[A](fa: Pot[A])(implicit arg0: CommutativeMonoid[A]): A
- Definition Classes
- Foldable → UnorderedFoldable
- def unorderedFoldMap[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: CommutativeMonoid[B]): B
- Definition Classes
- Foldable → UnorderedFoldable
- def unorderedSequence[G[_], A](fga: Pot[G[A]])(implicit arg0: CommutativeApplicative[G]): G[Pot[A]]
- Definition Classes
- Traverse → UnorderedTraverse
- def unorderedTraverse[G[_], A, B](sa: Pot[A])(f: (A) => G[B])(implicit arg0: CommutativeApplicative[G]): G[Pot[B]]
- Definition Classes
- Traverse → UnorderedTraverse
- def untilDefinedM[A](foa: Pot[Option[A]]): Pot[A]
- Definition Classes
- FlatMap
- def untilM[G[_], A](f: Pot[A])(cond: => Pot[Boolean])(implicit G: Alternative[G]): Pot[G[A]]
- Definition Classes
- Monad
- def untilM_[A](f: Pot[A])(cond: => Pot[Boolean]): Pot[Unit]
- Definition Classes
- Monad
- def unzip[A, B](fab: Pot[(A, B)]): (Pot[A], Pot[B])
- Definition Classes
- Functor
- def void[A](fa: Pot[A]): Pot[Unit]
- Definition Classes
- Functor
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def whenA[A](cond: Boolean)(f: => Pot[A]): Pot[Unit]
- Definition Classes
- Applicative
- def whileM[G[_], A](p: Pot[Boolean])(body: => Pot[A])(implicit G: Alternative[G]): Pot[G[A]]
- Definition Classes
- Monad
- def whileM_[A](p: Pot[Boolean])(body: => Pot[A]): Pot[Unit]
- Definition Classes
- Monad
- def widen[A, B >: A](fa: Pot[A]): Pot[B]
- Definition Classes
- Functor
- def zipAll[A, B](fa: Pot[A], fb: Pot[B], a: A, b: B): Pot[(A, B)]
- Definition Classes
- Align
- def zipWithIndex[A](fa: Pot[A]): Pot[(A, Int)]
- Definition Classes
- Traverse
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
- def ifA[A](fcond: Pot[Boolean])(ifTrue: Pot[A], ifFalse: Pot[A]): Pot[A]
- Definition Classes
- Apply
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.2) Dangerous method, use ifM (a flatMap) or ifF (a map) instead