trait NonEmptyTraverseLaws[F[_]] extends TraverseLaws[F] with ReducibleLaws[F]
Ordering
- Alphabetic
- By Inheritance
Inherited
- NonEmptyTraverseLaws
- ReducibleLaws
- TraverseLaws
- UnorderedTraverseLaws
- FoldableLaws
- UnorderedFoldableLaws
- FunctorLaws
- InvariantLaws
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Abstract Value Members
- implicit abstract def F: NonEmptyTraverse[F]
- Definition Classes
- NonEmptyTraverseLaws → ReducibleLaws → TraverseLaws → UnorderedTraverseLaws → FoldableLaws → UnorderedFoldableLaws → FunctorLaws → InvariantLaws
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collectFirstSome_Ref[A, B](fa: F[A], f: (A) => Option[B]): IsEq[Option[B]]
- Definition Classes
- FoldableLaws
- def collectFirst_Ref[A, B](fa: F[A], pf: PartialFunction[A, B]): IsEq[Option[B]]
- Definition Classes
- FoldableLaws
- def containsAllElementsFromItself[A](fa: F[A])(implicit eq: Eq[A]): Boolean
- Definition Classes
- UnorderedFoldableLaws
- def containsConsistentWithExists[A](fa: F[A], v: A)(implicit eq: Eq[A]): IsEq[Boolean]
- Definition Classes
- UnorderedFoldableLaws
- def containsConsistentWithForall[A](fa: F[A], v: A)(implicit eq: Eq[A]): IsEq[Boolean]
- Definition Classes
- UnorderedFoldableLaws
- def covariantComposition[A, B, C](fa: F[A], f: (A) => B, g: (B) => C): IsEq[F[C]]
- Definition Classes
- FunctorLaws
- def covariantIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- FunctorLaws
- def dropWhile_Ref[A](fa: F[A], p: (A) => Boolean): IsEq[List[A]]
- Definition Classes
- FoldableLaws
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def existsConsistentWithFind[A](fa: F[A], p: (A) => Boolean): Boolean
- Definition Classes
- FoldableLaws
- def existsLazy[A](fa: F[A]): Boolean
- Definition Classes
- UnorderedFoldableLaws
- def filter_Ref[A](fa: F[A], p: (A) => Boolean): IsEq[List[A]]
- Definition Classes
- FoldableLaws
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def foldMIdentity[A, B](fa: F[A], b: B, f: (B, A) => B): IsEq[B]
Monadic folding with identity monad is analogous to
foldLeft.Monadic folding with identity monad is analogous to
foldLeft.- Definition Classes
- FoldableLaws
- def foldMapDerived[A, B](fa: F[A], f: (A) => B)(implicit B: Monoid[B]): IsEq[B]
- Definition Classes
- TraverseLaws
- def foldRef[A](fa: F[A])(implicit A: Monoid[A]): IsEq[A]
- Definition Classes
- FoldableLaws
- def foldRightDeferConsistentWithFoldRight[A, B](fa: F[A], f: (B, A) => B)(implicit M: Monoid[B]): IsEq[B]
- Definition Classes
- FoldableLaws
- def foldRightLazy[A](fa: F[A]): Boolean
- Definition Classes
- FoldableLaws
- def forallConsistentWithExists[A](fa: F[A], p: (A) => Boolean): Boolean
- Definition Classes
- UnorderedFoldableLaws
- def forallEmpty[A](fa: F[A], p: (A) => Boolean): Boolean
If
F[A]is empty, forall must return true.If
F[A]is empty, forall must return true.- Definition Classes
- UnorderedFoldableLaws
- def forallLazy[A](fa: F[A]): Boolean
- Definition Classes
- UnorderedFoldableLaws
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getRef[A](fa: F[A], idx: Long): IsEq[Option[A]]
- Definition Classes
- FoldableLaws
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def invariantComposition[A, B, C](fa: F[A], f1: (A) => B, f2: (B) => A, g1: (B) => C, g2: (C) => B): IsEq[F[C]]
- Definition Classes
- InvariantLaws
- def invariantIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- InvariantLaws
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def leftFoldConsistentWithFoldMap[A, B](fa: F[A], f: (A) => B)(implicit M: Monoid[B]): IsEq[B]
- Definition Classes
- FoldableLaws
- def mapAccumulateRef[S, A, B](init: S, fa: F[A], f: (S, A) => (S, B)): IsEq[(S, F[B])]
- Definition Classes
- TraverseLaws
- def mapWithIndexRef[A, B](fa: F[A], f: (A, Int) => B): IsEq[F[B]]
- Definition Classes
- TraverseLaws
- def mapWithLongIndexRef[A, B](fa: F[A], f: (A, Long) => B): IsEq[F[B]]
- Definition Classes
- TraverseLaws
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmptyRef[A](fa: F[A]): IsEq[Boolean]
- Definition Classes
- UnorderedFoldableLaws
- def nonEmptyTraverseIdentity[A, B](fa: F[A], f: (A) => B): IsEq[F[B]]
- def nonEmptyTraverseParallelComposition[A, B, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (A) => N[B])(implicit N: Apply[N], M: Apply[M]): IsEq[(M[F[B]], N[F[B]])]
- def nonEmptyTraverseSequentialComposition[A, B, C, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (B) => N[C])(implicit N: Apply[N], M: Apply[M]): IsEq[Nested[M, N, F[C]]]
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def orderedConsistency[A](x: F[A], y: F[A])(implicit arg0: Eq[A], ev: Eq[F[A]]): IsEq[List[A]]
- Definition Classes
- FoldableLaws
- def reduceLeftOptionConsistentWithReduceLeftToOption[A](fa: F[A], f: (A, A) => A): IsEq[Option[A]]
reduceLeftOptionconsistent withreduceLeftToOptionreduceLeftOptionconsistent withreduceLeftToOption- Definition Classes
- FoldableLaws
- def reduceLeftToConsistentWithReduceMap[A, B](fa: F[A], f: (A) => B)(implicit B: Semigroup[B]): IsEq[B]
- Definition Classes
- ReducibleLaws
- def reduceMapDerived[A, B](fa: F[A], f: (A) => B)(implicit B: Semigroup[B]): IsEq[B]
- def reduceReduceLeftConsistent[B](fa: F[B])(implicit B: Semigroup[B]): IsEq[B]
- Definition Classes
- ReducibleLaws
- def reduceRightConsistentWithReduceRightOption[A](fa: F[A], f: (A, A) => A): IsEq[Option[A]]
- Definition Classes
- ReducibleLaws
- def reduceRightOptionConsistentWithReduceRightToOption[A](fa: F[A], f: (A, A) => A): IsEq[Option[A]]
reduceRightOptionconsistent withreduceRightToOptionreduceRightOptionconsistent withreduceRightToOption- Definition Classes
- FoldableLaws
- def reduceRightToConsistentWithReduceMap[A, B](fa: F[A], f: (A) => B)(implicit B: Semigroup[B]): IsEq[B]
- Definition Classes
- ReducibleLaws
- def reduceRightToConsistentWithReduceRightToOption[A, B](fa: F[A], f: (A) => B)(implicit B: Semigroup[B]): IsEq[Option[B]]
- Definition Classes
- ReducibleLaws
- def rightFoldConsistentWithFoldMap[A, B](fa: F[A], f: (A) => B)(implicit M: Monoid[B]): IsEq[B]
- Definition Classes
- FoldableLaws
- def sequenceConsistent[G[_], A](fa: F[G[A]])(implicit arg0: Applicative[G]): IsEq[G[Unit]]
- Definition Classes
- ReducibleLaws
- def sizeConsistent[A](fa: F[A]): IsEq[Long]
- Definition Classes
- ReducibleLaws
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def takeWhile_Ref[A](fa: F[A], p: (A) => Boolean): IsEq[List[A]]
- Definition Classes
- FoldableLaws
- def toListRef[A](fa: F[A]): IsEq[List[A]]
- Definition Classes
- FoldableLaws
- def toString(): String
- Definition Classes
- AnyRef → Any
- def traverseConsistent[G[_], A, B](fa: F[A], f: (A) => G[B])(implicit arg0: Applicative[G]): IsEq[G[Unit]]
- Definition Classes
- ReducibleLaws
- def traverseIdentity[A, B](fa: F[A], f: (A) => B): IsEq[F[B]]
- Definition Classes
- TraverseLaws
- def traverseOrderConsistent[A](fa: F[A]): IsEq[Option[A]]
- Definition Classes
- TraverseLaws
- def traverseParallelComposition[A, B, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (A) => N[B])(implicit N: Applicative[N], M: Applicative[M]): IsEq[(M[F[B]], N[F[B]])]
- Definition Classes
- TraverseLaws
- def traverseSequentialComposition[A, B, C, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (B) => N[C])(implicit N: Applicative[N], M: Applicative[M]): IsEq[Nested[M, N, F[C]]]
- Definition Classes
- TraverseLaws
- def traverseTap[A, B, G[_]](fa: F[A], f: (A) => G[B])(implicit G: Applicative[G]): IsEq[G[F[A]]]
- Definition Classes
- TraverseLaws
- def traverseWithIndexMRef[G[_], A, B](fa: F[A], f: (A, Int) => G[B])(implicit G: Monad[G]): IsEq[G[F[B]]]
- Definition Classes
- TraverseLaws
- def traverseWithLongIndexMRef[G[_], A, B](fa: F[A], f: (A, Long) => G[B])(implicit G: Monad[G]): IsEq[G[F[B]]]
- Definition Classes
- TraverseLaws
- def unorderedFoldConsistentWithUnorderedFoldMap[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): IsEq[A]
- Definition Classes
- UnorderedFoldableLaws
- def unorderedSequenceConsistent[A, G[_]](fga: F[G[A]])(implicit arg0: CommutativeApplicative[G]): IsEq[G[F[A]]]
- Definition Classes
- UnorderedTraverseLaws
- def unorderedTraverseIdentity[A, B](fa: F[A])(f: (A) => B)(implicit ev: Functor[F]): IsEq[F[B]]
- Definition Classes
- UnorderedTraverseLaws
- def unorderedTraverseParallelComposition[A, B, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (A) => N[B])(implicit N: CommutativeApplicative[N], M: CommutativeApplicative[M]): IsEq[(M[F[B]], N[F[B]])]
- Definition Classes
- UnorderedTraverseLaws
- def unorderedTraverseSequentialComposition[A, B, C, M[_], N[_]](fa: F[A], f: (A) => M[B], g: (B) => N[C])(implicit N: CommutativeApplicative[N], M: CommutativeApplicative[M]): IsEq[Nested[M, N, F[C]]]
- Definition Classes
- UnorderedTraverseLaws
- def updatedRef[A, B >: A](fa: F[A], idx: Long, b: B): IsEq[Option[F[B]]]
- Definition Classes
- TraverseLaws
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- 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()
- def zipWithIndexRef[A, B](fa: F[A], f: ((A, Int)) => B): IsEq[F[B]]
- Definition Classes
- TraverseLaws
- def zipWithLongIndexRef[A, B](fa: F[A], f: ((A, Long)) => B): IsEq[F[B]]
- Definition Classes
- TraverseLaws