Packages

implicit object PotCats extends MonadError[Pot, Throwable] with Traverse[Pot] with Align[Pot]

Linear Supertypes
Align[Pot], Traverse[Pot], UnorderedTraverse[Pot], Foldable[Pot], UnorderedFoldable[Pot], MonadError[Pot, Throwable], Monad[Pot], FlatMap[Pot], ApplicativeError[Pot, Throwable], Applicative[Pot], InvariantMonoidal[Pot], Apply[Pot], ApplyArityFunctions[Pot], InvariantSemigroupal[Pot], Semigroupal[Pot], Functor[Pot], Invariant[Pot], Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. PotCats
  2. Align
  3. Traverse
  4. UnorderedTraverse
  5. Foldable
  6. UnorderedFoldable
  7. MonadError
  8. Monad
  9. FlatMap
  10. ApplicativeError
  11. Applicative
  12. InvariantMonoidal
  13. Apply
  14. ApplyArityFunctions
  15. InvariantSemigroupal
  16. Semigroupal
  17. Functor
  18. Invariant
  19. Serializable
  20. AnyRef
  21. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def *>[A, B](fa: Pot[A])(fb: Pot[B]): Pot[B]
    Definition Classes
    Apply
    Annotations
    @inline()
  4. final def <*[A, B](fa: Pot[A])(fb: Pot[B]): Pot[A]
    Definition Classes
    Apply
    Annotations
    @inline()
  5. final def <*>[A, B](ff: Pot[(A) => B])(fa: Pot[A]): Pot[B]
    Definition Classes
    Apply
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def adaptError[A](fa: Pot[A])(pf: PartialFunction[Throwable, Throwable]): Pot[A]
    Definition Classes
    MonadError → ApplicativeError
  8. def align[A, B](fa: Pot[A], fb: Pot[B]): Pot[Ior[A, B]]
    Definition Classes
    PotCats → Align
  9. def alignCombine[A](fa1: Pot[A], fa2: Pot[A])(implicit arg0: Semigroup[A]): Pot[A]
    Definition Classes
    Align
  10. def alignWith[A, B, C](fa: Pot[A], fb: Pot[B])(f: (Ior[A, B]) => C): Pot[C]
    Definition Classes
    PotCats → Align
  11. def ap[A, B](ff: Pot[(A) => B])(fa: Pot[A]): Pot[B]
    Definition Classes
    FlatMap → Apply
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. def ap2[A, B, Z](ff: Pot[(A, B) => Z])(fa: Pot[A], fb: Pot[B]): Pot[Z]
    Definition Classes
    FlatMap → Apply
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. 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
  32. 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
  33. def as[A, B](fa: Pot[A], b: B): Pot[B]
    Definition Classes
    Functor
  34. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  35. def attempt[A](fa: Pot[A]): Pot[Either[Throwable, A]]
    Definition Classes
    ApplicativeError
  36. def attemptNarrow[EE, A](fa: Pot[A])(implicit tag: ClassTag[EE], ev: <:<[EE, Throwable]): Pot[Either[EE, A]]
    Definition Classes
    ApplicativeError
  37. def attemptT[A](fa: Pot[A]): EitherT[Pot, Throwable, A]
    Definition Classes
    ApplicativeError
  38. def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, Throwable]): Pot[A]
    Definition Classes
    ApplicativeError
  39. def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, Throwable]): Pot[A]
    Definition Classes
    ApplicativeError
  40. def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, Pot, Throwable]
    Definition Classes
    ApplicativeError
  41. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  42. def collectFirst[A, B](fa: Pot[A])(pf: PartialFunction[A, B]): Option[B]
    Definition Classes
    Foldable
  43. def collectFirstSome[A, B](fa: Pot[A])(f: (A) => Option[B]): Option[B]
    Definition Classes
    Foldable
  44. def collectFirstSomeM[G[_], A, B](fa: Pot[A])(f: (A) => G[Option[B]])(implicit G: Monad[G]): G[Option[B]]
    Definition Classes
    Foldable
  45. def collectFold[A, B](fa: Pot[A])(f: PartialFunction[A, B])(implicit B: Monoid[B]): B
    Definition Classes
    Foldable
  46. def collectFoldSome[A, B](fa: Pot[A])(f: (A) => Option[B])(implicit B: Monoid[B]): B
    Definition Classes
    Foldable
  47. def combineAll[A](fa: Pot[A])(implicit arg0: Monoid[A]): A
    Definition Classes
    Foldable
  48. def combineAllOption[A](fa: Pot[A])(implicit ev: Semigroup[A]): Option[A]
    Definition Classes
    Foldable
  49. def compose[G[_]](implicit arg0: Traverse[G]): Traverse[[α]Pot[G[α]]]
    Definition Classes
    Traverse
  50. def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]Pot[G[α]]]
    Definition Classes
    Foldable
  51. def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]Pot[G[α]]]
    Definition Classes
    Applicative
  52. def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]Pot[G[α]]]
    Definition Classes
    Apply
  53. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]Pot[G[α]]]
    Definition Classes
    Functor
  54. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]Pot[G[α]]]
    Definition Classes
    Invariant
  55. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]Pot[G[α]]]
    Definition Classes
    InvariantSemigroupal
  56. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]Pot[G[α]]]
    Definition Classes
    Functor → Invariant
  57. def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]Pot[G[α]]]
    Definition Classes
    Applicative
  58. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]Pot[G[α]]]
    Definition Classes
    Invariant
  59. def count[A](fa: Pot[A])(p: (A) => Boolean): Long
    Definition Classes
    UnorderedFoldable
  60. def dropWhile_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
    Definition Classes
    Foldable
  61. def ensure[A](fa: Pot[A])(error: => Throwable)(predicate: (A) => Boolean): Pot[A]
    Definition Classes
    MonadError
  62. def ensureOr[A](fa: Pot[A])(error: (A) => Throwable)(predicate: (A) => Boolean): Pot[A]
    Definition Classes
    MonadError
  63. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  64. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  65. def exists[A](fa: Pot[A])(p: (A) => Boolean): Boolean
    Definition Classes
    Foldable → UnorderedFoldable
  66. def existsM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
    Definition Classes
    Foldable
  67. def filter_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
    Definition Classes
    Foldable
  68. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  69. def find[A](fa: Pot[A])(f: (A) => Boolean): Option[A]
    Definition Classes
    Foldable
  70. def findM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Option[A]]
    Definition Classes
    Foldable
  71. def flatMap[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[B]
    Definition Classes
    PotCats → FlatMap
  72. def flatSequence[G[_], A](fgfa: Pot[G[Pot[A]]])(implicit G: Applicative[G], F: FlatMap[Pot]): G[Pot[A]]
    Definition Classes
    Traverse
  73. def flatTap[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[A]
    Definition Classes
    FlatMap
  74. 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
  75. def flatten[A](ffa: Pot[Pot[A]]): Pot[A]
    Definition Classes
    FlatMap
  76. final def fmap[A, B](fa: Pot[A])(f: (A) => B): Pot[B]
    Definition Classes
    Functor
  77. def fold[A](fa: Pot[A])(implicit A: Monoid[A]): A
    Definition Classes
    Foldable
  78. def foldA[G[_], A](fga: Pot[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A]
    Definition Classes
    Foldable
  79. def foldK[G[_], A](fga: Pot[G[A]])(implicit G: MonoidK[G]): G[A]
    Definition Classes
    Foldable
  80. def foldLeft[A, B](fa: Pot[A], b: B)(f: (B, A) => B): B
    Definition Classes
    PotCats → Foldable
  81. 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
  82. def foldM[G[_], A, B](fa: Pot[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
    Definition Classes
    Foldable
  83. def foldMap[A, B](fa: Pot[A])(f: (A) => B)(implicit B: Monoid[B]): B
    Definition Classes
    Foldable
  84. def foldMapA[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]
    Definition Classes
    Foldable
  85. def foldMapK[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: MonoidK[G]): G[B]
    Definition Classes
    Foldable
  86. def foldMapM[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]
    Definition Classes
    Foldable
  87. def foldRight[A, B](fa: Pot[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]
    Definition Classes
    PotCats → Foldable
  88. 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
  89. def forall[A](fa: Pot[A])(p: (A) => Boolean): Boolean
    Definition Classes
    Foldable → UnorderedFoldable
  90. def forallM[G[_], A](fa: Pot[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
    Definition Classes
    Foldable
  91. def foreverM[A, B](fa: Pot[A]): Pot[B]
    Definition Classes
    FlatMap
  92. def fproduct[A, B](fa: Pot[A])(f: (A) => B): Pot[(A, B)]
    Definition Classes
    Functor
  93. def fromEither[A](x: Either[Throwable, A]): Pot[A]
    Definition Classes
    ApplicativeError
  94. def fromOption[A](oa: Option[A], ifEmpty: => Throwable): Pot[A]
    Definition Classes
    ApplicativeError
  95. def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, Throwable]): Pot[A]
    Definition Classes
    ApplicativeError
  96. def fromValidated[A](x: Validated[Throwable, A]): Pot[A]
    Definition Classes
    ApplicativeError
  97. def functor: Functor[Pot]
    Definition Classes
    PotCats → Align
  98. def get[A](fa: Pot[A])(idx: Long): Option[A]
    Definition Classes
    Foldable
  99. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  100. def handleError[A](fa: Pot[A])(f: (Throwable) => A): Pot[A]
    Definition Classes
    ApplicativeError
  101. def handleErrorWith[A](fa: Pot[A])(f: (Throwable) => Pot[A]): Pot[A]
    Definition Classes
    PotCats → ApplicativeError
  102. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  103. def ifA[A](fcond: Pot[Boolean])(ifTrue: Pot[A], ifFalse: Pot[A]): Pot[A]
    Definition Classes
    Apply
  104. def ifF[A](fb: Pot[Boolean])(ifTrue: => A, ifFalse: => A): Pot[A]
    Definition Classes
    Functor
  105. def ifM[B](fa: Pot[Boolean])(ifTrue: => Pot[B], ifFalse: => Pot[B]): Pot[B]
    Definition Classes
    FlatMap
  106. def imap[A, B](fa: Pot[A])(f: (A) => B)(g: (B) => A): Pot[B]
    Definition Classes
    Functor → Invariant
  107. def intercalate[A](fa: Pot[A], a: A)(implicit A: Monoid[A]): A
    Definition Classes
    Foldable
  108. def intersperseList[A](xs: List[A], x: A): List[A]
    Attributes
    protected
    Definition Classes
    Foldable
  109. def isEmpty[A](fa: Pot[A]): Boolean
    Definition Classes
    Foldable → UnorderedFoldable
  110. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  111. def iterateForeverM[A, B](a: A)(f: (A) => Pot[A]): Pot[B]
    Definition Classes
    FlatMap
  112. def iterateUntil[A](f: Pot[A])(p: (A) => Boolean): Pot[A]
    Definition Classes
    Monad
  113. def iterateUntilM[A](init: A)(f: (A) => Pot[A])(p: (A) => Boolean): Pot[A]
    Definition Classes
    Monad
  114. def iterateWhile[A](f: Pot[A])(p: (A) => Boolean): Pot[A]
    Definition Classes
    Monad
  115. def iterateWhileM[A](init: A)(f: (A) => Pot[A])(p: (A) => Boolean): Pot[A]
    Definition Classes
    Monad
  116. def lift[A, B](f: (A) => B): (Pot[A]) => Pot[B]
    Definition Classes
    Functor
  117. def map[A, B](fa: Pot[A])(f: (A) => B): Pot[B]
    Definition Classes
    Traverse → Functor
  118. 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
  119. 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
  120. 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
  121. 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
  122. 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
  123. 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
  124. 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
  125. 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
  126. 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
  127. 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
  128. def map2[A, B, Z](fa: Pot[A], fb: Pot[B])(f: (A, B) => Z): Pot[Z]
    Definition Classes
    FlatMap → Apply
  129. 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
  130. 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
  131. 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
  132. def map2Eval[A, B, Z](fa: Pot[A], fb: Eval[Pot[B]])(f: (A, B) => Z): Eval[Pot[Z]]
    Definition Classes
    Apply
  133. 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
  134. 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
  135. 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
  136. 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
  137. 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
  138. 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
  139. 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
  140. def mapWithIndex[A, B](fa: Pot[A])(f: (A, Int) => B): Pot[B]
    Definition Classes
    Traverse
  141. def maximumByOption[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
    Definition Classes
    Foldable
  142. def maximumOption[A](fa: Pot[A])(implicit A: Order[A]): Option[A]
    Definition Classes
    Foldable
  143. def minimumByOption[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
    Definition Classes
    Foldable
  144. def minimumOption[A](fa: Pot[A])(implicit A: Order[A]): Option[A]
    Definition Classes
    Foldable
  145. def mproduct[A, B](fa: Pot[A])(f: (A) => Pot[B]): Pot[(A, B)]
    Definition Classes
    FlatMap
  146. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  147. def nonEmpty[A](fa: Pot[A]): Boolean
    Definition Classes
    Foldable → UnorderedFoldable
  148. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  149. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  150. def onError[A](fa: Pot[A])(pf: PartialFunction[Throwable, Pot[Unit]]): Pot[A]
    Definition Classes
    ApplicativeError
  151. def padZip[A, B](fa: Pot[A], fb: Pot[B]): Pot[(Option[A], Option[B])]
    Definition Classes
    Align
  152. def padZipWith[A, B, C](fa: Pot[A], fb: Pot[B])(f: (Option[A], Option[B]) => C): Pot[C]
    Definition Classes
    Align
  153. 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
  154. 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
  155. def partitionEither[A, B, C](fa: Pot[A])(f: (A) => Either[B, C])(implicit A: Alternative[Pot]): (Pot[B], Pot[C])
    Definition Classes
    Foldable
  156. 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
  157. def point[A](a: A): Pot[A]
    Definition Classes
    InvariantMonoidal
  158. def product[A, B](fa: Pot[A], fb: Pot[B]): Pot[(A, B)]
    Definition Classes
    FlatMap → Apply → Semigroupal
  159. def productL[A, B](fa: Pot[A])(fb: Pot[B]): Pot[A]
    Definition Classes
    FlatMap → Apply
  160. def productLEval[A, B](fa: Pot[A])(fb: Eval[Pot[B]]): Pot[A]
    Definition Classes
    FlatMap
  161. def productR[A, B](fa: Pot[A])(fb: Pot[B]): Pot[B]
    Definition Classes
    FlatMap → Apply
  162. def productREval[A, B](fa: Pot[A])(fb: Eval[Pot[B]]): Pot[B]
    Definition Classes
    FlatMap
  163. def pure[A](a: A): Pot[A]
    Definition Classes
    PotCats → Applicative
  164. def raiseError[A](t: Throwable): Pot[A]
    Definition Classes
    PotCats → ApplicativeError
  165. def recover[A](fa: Pot[A])(pf: PartialFunction[Throwable, A]): Pot[A]
    Definition Classes
    ApplicativeError
  166. def recoverWith[A](fa: Pot[A])(pf: PartialFunction[Throwable, Pot[A]]): Pot[A]
    Definition Classes
    ApplicativeError
  167. def redeem[A, B](fa: Pot[A])(recover: (Throwable) => B, f: (A) => B): Pot[B]
    Definition Classes
    ApplicativeError
  168. def redeemWith[A, B](fa: Pot[A])(recover: (Throwable) => Pot[B], bind: (A) => Pot[B]): Pot[B]
    Definition Classes
    MonadError
  169. def reduceLeftOption[A](fa: Pot[A])(f: (A, A) => A): Option[A]
    Definition Classes
    Foldable
  170. def reduceLeftToOption[A, B](fa: Pot[A])(f: (A) => B)(g: (B, A) => B): Option[B]
    Definition Classes
    Foldable
  171. def reduceRightOption[A](fa: Pot[A])(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]]
    Definition Classes
    Foldable
  172. def reduceRightToOption[A, B](fa: Pot[A])(f: (A) => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]
    Definition Classes
    Foldable
  173. def replicateA[A](n: Int, fa: Pot[A]): Pot[List[A]]
    Definition Classes
    Applicative
  174. def rethrow[A, EE <: Throwable](fa: Pot[Either[EE, A]]): Pot[A]
    Definition Classes
    MonadError
  175. def sequence[G[_], A](fga: Pot[G[A]])(implicit arg0: Applicative[G]): G[Pot[A]]
    Definition Classes
    Traverse
  176. def sequence_[G[_], A](fga: Pot[G[A]])(implicit arg0: Applicative[G]): G[Unit]
    Definition Classes
    Foldable
  177. def size[A](fa: Pot[A]): Long
    Definition Classes
    UnorderedFoldable
  178. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  179. def tailRecM[A, B](a: A)(f: (A) => Pot[Either[A, B]]): Pot[B]
    Definition Classes
    PotCats → FlatMap
    Annotations
    @tailrec()
  180. def takeWhile_[A](fa: Pot[A])(p: (A) => Boolean): List[A]
    Definition Classes
    Foldable
  181. def toIterable[A](fa: Pot[A]): Iterable[A]
    Definition Classes
    Foldable
  182. def toList[A](fa: Pot[A]): List[A]
    Definition Classes
    Foldable
  183. def toString(): String
    Definition Classes
    AnyRef → Any
  184. def traverse[F[_], A, B](fa: Pot[A])(f: (A) => F[B])(implicit F: Applicative[F]): F[Pot[B]]
    Definition Classes
    PotCats → Traverse
  185. def traverseWithIndexM[G[_], A, B](fa: Pot[A])(f: (A, Int) => G[B])(implicit G: Monad[G]): G[Pot[B]]
    Definition Classes
    Traverse
  186. def traverse_[G[_], A, B](fa: Pot[A])(f: (A) => G[B])(implicit G: Applicative[G]): G[Unit]
    Definition Classes
    Foldable
  187. def tuple10[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
    Definition Classes
    ApplyArityFunctions
  188. def tuple11[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
    Definition Classes
    ApplyArityFunctions
  189. def tuple12[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
    Definition Classes
    ApplyArityFunctions
  190. def tuple13[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
    Definition Classes
    ApplyArityFunctions
  191. def tuple14[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
    Definition Classes
    ApplyArityFunctions
  192. def tuple15[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
    Definition Classes
    ApplyArityFunctions
  193. def tuple16[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
    Definition Classes
    ApplyArityFunctions
  194. def tuple17[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
    Definition Classes
    ApplyArityFunctions
  195. def tuple18[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
    Definition Classes
    ApplyArityFunctions
  196. def tuple19[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
    Definition Classes
    ApplyArityFunctions
  197. def tuple2[A, B](f1: Pot[A], f2: Pot[B]): Pot[(A, B)]
    Definition Classes
    ApplyArityFunctions
  198. def tuple20[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
    Definition Classes
    ApplyArityFunctions
  199. def tuple21[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
    Definition Classes
    ApplyArityFunctions
  200. def tuple22[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[(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
  201. def tuple3[A0, A1, A2, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2]): Pot[(A0, A1, A2)]
    Definition Classes
    ApplyArityFunctions
  202. def tuple4[A0, A1, A2, A3, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3]): Pot[(A0, A1, A2, A3)]
    Definition Classes
    ApplyArityFunctions
  203. def tuple5[A0, A1, A2, A3, A4, Z](f0: Pot[A0], f1: Pot[A1], f2: Pot[A2], f3: Pot[A3], f4: Pot[A4]): Pot[(A0, A1, A2, A3, A4)]
    Definition Classes
    ApplyArityFunctions
  204. def tuple6[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[(A0, A1, A2, A3, A4, A5)]
    Definition Classes
    ApplyArityFunctions
  205. def tuple7[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[(A0, A1, A2, A3, A4, A5, A6)]
    Definition Classes
    ApplyArityFunctions
  206. def tuple8[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[(A0, A1, A2, A3, A4, A5, A6, A7)]
    Definition Classes
    ApplyArityFunctions
  207. def tuple9[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[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
    Definition Classes
    ApplyArityFunctions
  208. def tupleLeft[A, B](fa: Pot[A], b: B): Pot[(B, A)]
    Definition Classes
    Functor
  209. def tupleRight[A, B](fa: Pot[A], b: B): Pot[(A, B)]
    Definition Classes
    Functor
  210. def unit: Pot[Unit]
    Definition Classes
    Applicative → InvariantMonoidal
  211. def unlessA[A](cond: Boolean)(f: => Pot[A]): Pot[Unit]
    Definition Classes
    Applicative
  212. def unorderedFold[A](fa: Pot[A])(implicit arg0: CommutativeMonoid[A]): A
    Definition Classes
    Foldable → UnorderedFoldable
  213. def unorderedFoldMap[A, B](fa: Pot[A])(f: (A) => B)(implicit arg0: CommutativeMonoid[B]): B
    Definition Classes
    Foldable → UnorderedFoldable
  214. def unorderedSequence[G[_], A](fga: Pot[G[A]])(implicit arg0: CommutativeApplicative[G]): G[Pot[A]]
    Definition Classes
    Traverse → UnorderedTraverse
  215. def unorderedTraverse[G[_], A, B](sa: Pot[A])(f: (A) => G[B])(implicit arg0: CommutativeApplicative[G]): G[Pot[B]]
    Definition Classes
    Traverse → UnorderedTraverse
  216. def untilDefinedM[A](foa: Pot[Option[A]]): Pot[A]
    Definition Classes
    FlatMap
  217. def untilM[G[_], A](f: Pot[A])(cond: => Pot[Boolean])(implicit G: Alternative[G]): Pot[G[A]]
    Definition Classes
    Monad
  218. def untilM_[A](f: Pot[A])(cond: => Pot[Boolean]): Pot[Unit]
    Definition Classes
    Monad
  219. def unzip[A, B](fab: Pot[(A, B)]): (Pot[A], Pot[B])
    Definition Classes
    Functor
  220. def void[A](fa: Pot[A]): Pot[Unit]
    Definition Classes
    Functor
  221. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  222. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  223. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  224. def whenA[A](cond: Boolean)(f: => Pot[A]): Pot[Unit]
    Definition Classes
    Applicative
  225. def whileM[G[_], A](p: Pot[Boolean])(body: => Pot[A])(implicit G: Alternative[G]): Pot[G[A]]
    Definition Classes
    Monad
  226. def whileM_[A](p: Pot[Boolean])(body: => Pot[A]): Pot[Unit]
    Definition Classes
    Monad
  227. def widen[A, B >: A](fa: Pot[A]): Pot[B]
    Definition Classes
    Functor
  228. def zipWithIndex[A](fa: Pot[A]): Pot[(A, Int)]
    Definition Classes
    Traverse

Inherited from Align[Pot]

Inherited from Traverse[Pot]

Inherited from UnorderedTraverse[Pot]

Inherited from Foldable[Pot]

Inherited from UnorderedFoldable[Pot]

Inherited from MonadError[Pot, Throwable]

Inherited from Monad[Pot]

Inherited from FlatMap[Pot]

Inherited from ApplicativeError[Pot, Throwable]

Inherited from Applicative[Pot]

Inherited from InvariantMonoidal[Pot]

Inherited from Apply[Pot]

Inherited from ApplyArityFunctions[Pot]

Inherited from InvariantSemigroupal[Pot]

Inherited from Semigroupal[Pot]

Inherited from Functor[Pot]

Inherited from Invariant[Pot]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped