Ops

Type Members

abstract type TypeClassType <: Foldable[F]

Abstract Value Members

abstract def self: F[D]
abstract val typeClassInstance: TypeClassType

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[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collectFirst[B](pf: PartialFunction[D, B]): Option[B]
def collectFirstSome[B](f: (D) ⇒ Option[B]): Option[B]
def combineAll(implicit arg0: Monoid[D]): D
def dropWhile_(p: (D) ⇒ Boolean): List[D]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def existsM[G[_]](p: (D) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]
def filter_(p: (D) ⇒ Boolean): List[D]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (D) ⇒ Boolean): Option[D]
def fold(implicit A: Monoid[D]): D
def foldK[G[_], A](implicit arg0: <:<[D, G[A]], G: MonoidK[G]): G[A]
def foldLeft[B](b: B)(f: (B, D) ⇒ B): B
def foldLeftM[G[_], B](z: B)(f: (B, D) ⇒ G[B])(implicit G: Monad[G]): G[B]
def foldM[G[_], B](z: B)(f: (B, D) ⇒ G[B])(implicit G: Monad[G]): G[B]
def foldMap[B](f: (D) ⇒ B)(implicit B: Monoid[B]): B
def foldMapM[G[_], B](f: (D) ⇒ G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]
def foldRight[B](lb: Eval[B])(f: (D, Eval[B]) ⇒ Eval[B]): Eval[B]
def forallM[G[_]](p: (D) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]
def get(idx: Long): Option[D]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def intercalate(a: D)(implicit A: Monoid[D]): D
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def maximumOption(implicit A: Order[D]): Option[D]
def minimumOption(implicit A: Order[D]): Option[D]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def partitionEither[B, C](f: (D) ⇒ Either[B, C])(implicit A: Alternative[F]): (F[B], F[C])
def reduceLeftOption(f: (D, D) ⇒ D): Option[D]
def reduceLeftToOption[B](f: (D) ⇒ B)(g: (B, D) ⇒ B): Option[B]
def reduceRightOption(f: (D, Eval[D]) ⇒ Eval[D]): Eval[Option[D]]
def reduceRightToOption[B](f: (D) ⇒ B)(g: (D, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]
def sequence_[G[_], A](implicit arg0: <:<[D, G[A]], arg1: Applicative[G]): G[Unit]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def takeWhile_(p: (D) ⇒ Boolean): List[D]
def toList: List[D]
def toString(): String

Definition Classes
AnyRef → Any
def traverse_[G[_], B](f: (D) ⇒ G[B])(implicit G: Applicative[G]): G[Unit]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package Foldable

trait Ops[F[_], D] extends AnyRef

Type Members

abstract type TypeClassType <: Foldable[F]

Abstract Value Members

abstract def self: F[D]

abstract val typeClassInstance: TypeClassType

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectFirst[B](pf: PartialFunction[D, B]): Option[B]

def collectFirstSome[B](f: (D) ⇒ Option[B]): Option[B]

def combineAll(implicit arg0: Monoid[D]): D

def dropWhile_(p: (D) ⇒ Boolean): List[D]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def existsM[G[_]](p: (D) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

def filter_(p: (D) ⇒ Boolean): List[D]

def finalize(): Unit

def find(f: (D) ⇒ Boolean): Option[D]

def fold(implicit A: Monoid[D]): D

def foldK[G[_], A](implicit arg0: <:<[D, G[A]], G: MonoidK[G]): G[A]

def foldLeft[B](b: B)(f: (B, D) ⇒ B): B

def foldLeftM[G[_], B](z: B)(f: (B, D) ⇒ G[B])(implicit G: Monad[G]): G[B]

def foldM[G[_], B](z: B)(f: (B, D) ⇒ G[B])(implicit G: Monad[G]): G[B]

def foldMap[B](f: (D) ⇒ B)(implicit B: Monoid[B]): B

def foldMapM[G[_], B](f: (D) ⇒ G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]

def foldRight[B](lb: Eval[B])(f: (D, Eval[B]) ⇒ Eval[B]): Eval[B]

def forallM[G[_]](p: (D) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

def get(idx: Long): Option[D]

final def getClass(): Class[_]

def hashCode(): Int

def intercalate(a: D)(implicit A: Monoid[D]): D

final def isInstanceOf[T0]: Boolean

def maximumOption(implicit A: Order[D]): Option[D]

def minimumOption(implicit A: Order[D]): Option[D]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def partitionEither[B, C](f: (D) ⇒ Either[B, C])(implicit A: Alternative[F]): (F[B], F[C])

def reduceLeftOption(f: (D, D) ⇒ D): Option[D]

def reduceLeftToOption[B](f: (D) ⇒ B)(g: (B, D) ⇒ B): Option[B]

def reduceRightOption(f: (D, Eval[D]) ⇒ Eval[D]): Eval[Option[D]]

def reduceRightToOption[B](f: (D) ⇒ B)(g: (D, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]

def sequence_[G[_], A](implicit arg0: <:<[D, G[A]], arg1: Applicative[G]): G[Unit]

final def synchronized[T0](arg0: ⇒ T0): T0

def takeWhile_(p: (D) ⇒ Boolean): List[D]

def toList: List[D]

def toString(): String

def traverse_[G[_], B](f: (D) ⇒ G[B])(implicit G: Applicative[G]): G[Unit]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped