sealed
class
CoalgebraOps[F[_], A] extends AnyRef
Instance Constructors

new
CoalgebraOps(self: Coalgebra[F, A])
Value Members

final
def
!=(arg0: Any): Boolean

final
def
##(): Int

final
def
==(arg0: Any): Boolean

def
all(p: (CoalgebraOps[F, A]) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[F], B: Foldable[F]): slamdata.Predef.Boolean

def
any(p: (CoalgebraOps[F, A]) ⇒ slamdata.Predef.Boolean)(implicit BF: Functor[F], B: Foldable[F]): slamdata.Predef.Boolean

final
def
asInstanceOf[T0]: T0

def
attributeTopDown[U, A](z: A)(f: (A, F[CoalgebraOps[F, A]]) ⇒ A)(implicit U: Aux[U, [γ$56$]EnvT[A, F, γ$56$]], BF: Functor[F]): U

def
attributeTopDownM[M[_], U, A](z: A)(f: (A, F[CoalgebraOps[F, A]]) ⇒ M[A])(implicit arg0: Monad[M], U: Aux[U, [γ$57$]EnvT[A, F, γ$57$]], BT: Traverse[F]): M[U]

def
cata[A](f: Algebra[F, A])(implicit BF: Functor[F]): A

def
cataM[M[_], A](f: AlgebraM[M, F, A])(implicit arg0: Monad[M], BT: Traverse[F]): M[A]

def
children[U](implicit U: Aux[U, [β$55$]ListF[CoalgebraOps[F, A], β$55$]], BT: Traverse[F]): U

def
chrono[F[_], B](g: GAlgebra[[β$3$]Cofree[F, β$3$], F, B], f: GCoalgebra[[β$4$]Free[F, β$4$], F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
clone(): AnyRef

def
codyna[F[_], B](φ: Algebra[F, B], ψ: GCoalgebra[[β$1$]Free[F, β$1$], F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
codynaM[M[_], F[_], B](φ: AlgebraM[M, F, B], ψ: GCoalgebraM[[β$2$]Free[F, β$2$], M, F, CoalgebraOps[F, A]])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]

def
coelgot[F[_], B](φ: ElgotAlgebra[[β$6$](CoalgebraOps[F, A], β$6$), F, B], ψ: Coalgebra[F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
colambek(implicit F: Functor[FF]): A

def
collect[U, B](pf: slamdata.Predef.PartialFunction[CoalgebraOps[F, A], B])(implicit arg0: Monoid[U], F: Aux[U, [β$58$]ListF[B, β$58$]], BF: Functor[F], B: Foldable[F]): U

def
contains(c: CoalgebraOps[F, A])(implicit T: Equal[CoalgebraOps[F, A]], BF: Functor[F], B: Foldable[F]): slamdata.Predef.Boolean

def
convertTo[R](implicit R: Aux[R, F], BF: Functor[F]): R

def
dyna[F[_], B](φ: GAlgebra[[β$0$]Cofree[F, β$0$], F, B], ψ: Coalgebra[F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
elgot[F[_], B](φ: Algebra[F, B], ψ: ElgotCoalgebra[[β$5$]\/[B, β$5$], F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
elgotCata[W[_], A](k: DistributiveLaw[F, W], g: ElgotAlgebra[W, F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
elgotCataM[W[_], M[_], A](k: DistributiveLaw[F, [A]M[W[A]]], g: ElgotAlgebraM[W, M, F, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], BT: Traverse[F]): M[A]

def
elgotHisto[A](f: ElgotAlgebra[[β$50$]Cofree[F, β$50$], F, A])(implicit BF: Functor[F]): A

def
elgotPara[A](f: ElgotAlgebra[[β$39$](CoalgebraOps[F, A], β$39$), F, A])(implicit BF: Functor[F]): A

def
elgotZygo[A, B](f: Algebra[F, B], g: ElgotAlgebra[[β$43$](B, β$43$), F, A])(implicit BF: Functor[F]): A

def
elgotZygoM[A, B, M[_]](f: AlgebraM[M, F, B], g: ElgotAlgebraM[[β$44$](B, β$44$), M, F, A])(implicit arg0: Monad[M], BT: Traverse[F]): M[A]

def
embed(implicit F: Functor[FF]): A



def
finalize(): Unit

def
foldMap[Z](f: (CoalgebraOps[F, A]) ⇒ Z)(implicit arg0: Monoid[Z], BF: Functor[F], B: Foldable[F]): Z

def
foldMapM[M[_], Z](f: (CoalgebraOps[F, A]) ⇒ M[Z])(implicit arg0: Monad[M], arg1: Monoid[Z], BF: Functor[F], B: Foldable[F]): M[Z]

def
futuM[T, M[_], F[_]](f: GCoalgebraM[[β$13$]Free[F, β$13$], M, F, CoalgebraOps[F, A]])(implicit arg0: Monad[M], arg1: Traverse[F], T: Aux[T, F]): M[T]

def
gElgotZygo[W[_], A, B](f: Algebra[F, B], w: DistributiveLaw[F, W], g: ElgotAlgebra[[γ$46$]EnvT[B, W, γ$46$], F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
gcata[W[_], A](k: DistributiveLaw[F, W], g: GAlgebra[W, F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
gcataM[W[_], M[_], A](w: DistributiveLaw[F, W], g: GAlgebraM[W, M, F, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], BT: Traverse[F]): M[A]

def
gcataZygo[W[_], A, B](w: DistributiveLaw[F, W], f: GAlgebra[W, F, B], g: GAlgebra[[β$52$](B, β$52$), F, A])(implicit arg0: Comonad[W], BF: Functor[F], BU: Unzip[F]): A

def
generalize[N[_]](implicit arg0: Applicative[N], F: Functor[F]): GCoalgebra[N, F, A]

def
generalizeElgot[N[_]](implicit arg0: Applicative[N]): ElgotCoalgebra[N, F, A]

def
generalizeM[M[_]](implicit arg0: Applicative[M]): CoalgebraM[M, F, A]

final
def
getClass(): Class[_]

def
ghisto[H[_], A](g: DistributiveLaw[F, H], f: GAlgebra[[β$51$]Cofree[H, β$51$], F, A])(implicit arg0: Functor[H], BF: Functor[F]): A

def
ghyloM[W[_], N[_], M[_], F[_], B](w: DistributiveLaw[F, W], n: DistributiveLaw[N, F], f: GAlgebraM[W, M, F, B], g: GCoalgebraM[N, M, F, CoalgebraOps[F, A]])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[N], arg3: Traverse[N], arg4: Monad[M], arg5: Traverse[F]): M[B]

def
gpara[W[_], A](e: DistributiveLaw[F, W], f: GAlgebra[[γ$17$]EnvT[CoalgebraOps[F, A], W, γ$17$], F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
gprepro[W[_], A](k: DistributiveLaw[F, W], e: ~>[F, F], f: GAlgebra[W, F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
gzygo[W[_], A, B](f: Algebra[F, B], w: DistributiveLaw[F, W], g: GAlgebra[[γ$45$]EnvT[B, W, γ$45$], F, A])(implicit arg0: Comonad[W], BF: Functor[F]): A

def
hashCode(): Int

def
histo[A](f: GAlgebra[[β$49$]Cofree[F, β$49$], F, A])(implicit BF: Functor[F]): A

def
hylo[F[_], B](f: Algebra[F, B], g: Coalgebra[F, CoalgebraOps[F, A]])(implicit arg0: Functor[F]): B

def
hyloM[M[_], F[_], B](f: AlgebraM[M, F, B], g: CoalgebraM[M, F, CoalgebraOps[F, A]])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]

final
def
isInstanceOf[T0]: Boolean

def
isLeaf(implicit BT: Traverse[F]): slamdata.Predef.Boolean

def
lambek(implicit BF: Functor[F]): F[CoalgebraOps[F, A]]

def
merge[B](fb: ⇒ CoalgebraOps[F, B]): slamdata.Predef.Option[CoalgebraOps[F, (A, B)]]

def
mergeWith[B, C, D](fb: ⇒ CoalgebraOps[F, B])(g: (A, B) ⇒ D)(implicit F: Functor[[A]CoalgebraOps[F, A]]): slamdata.Predef.Option[CoalgebraOps[F, D]]

def
mutu[A, B](f: GAlgebra[[β$47$](A, β$47$), F, B], g: GAlgebra[[β$48$](B, β$48$), F, A])(implicit BF: Functor[F]): A


final
def
notify(): Unit

final
def
notifyAll(): Unit

def
para[A](f: GAlgebra[[β$38$](CoalgebraOps[F, A], β$38$), F, A])(implicit BF: Functor[F]): A

def
paraM[M[_], A](f: GAlgebraM[[β$40$](CoalgebraOps[F, A], β$40$), M, F, A])(implicit arg0: Monad[M], BT: Traverse[F]): M[A]

def
paraMerga[A](that: CoalgebraOps[F, A])(f: (CoalgebraOps[F, A], CoalgebraOps[F, A], slamdata.Predef.Option[F[A]]) ⇒ A)(implicit BF: Functor[F], BM: Merge[F]): A

def
paraZygo[A, B](f: GAlgebra[[β$53$](CoalgebraOps[F, A], β$53$), F, B], g: GAlgebra[[β$54$](B, β$54$), F, A])(implicit BF: Functor[F], BU: Unzip[F]): A

def
prepro[A](e: ~>[F, F], f: Algebra[F, A])(implicit BF: Functor[F]): A

def
project(implicit BF: Functor[F]): F[CoalgebraOps[F, A]]

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

def
toString(): String

def
topDownCata[A](a: A)(f: (A, CoalgebraOps[F, A]) ⇒ (A, CoalgebraOps[F, A]))(implicit BF: Functor[F]): CoalgebraOps[F, A]

def
topDownCataM[M[_], A](a: A)(f: (A, CoalgebraOps[F, A]) ⇒ M[(A, CoalgebraOps[F, A])])(implicit arg0: Monad[M], BT: Traverse[F]): M[CoalgebraOps[F, A]]

def
transAnaM[M[_], U, G[_]](f: TransformM[M, CoalgebraOps[F, A], F, G])(implicit arg0: Monad[M], arg1: Traverse[G], U: Aux[U, G], BF: Functor[F]): M[U]


def
transAnaTM[M[_]](f: (CoalgebraOps[F, A]) ⇒ M[CoalgebraOps[F, A]])(implicit arg0: Monad[M], BF: Traverse[F]): M[CoalgebraOps[F, A]]

def
transApo[U, G[_]](f: CoalgebraicGTransform[[β$0$]\/[U, β$0$], CoalgebraOps[F, A], F, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[F]): U


def
transCataM[M[_], U, G[_]](f: TransformM[M, U, F, G])(implicit arg0: Monad[M], arg1: Functor[G], U: Aux[U, G], BT: Traverse[F]): M[U]


def
transCataTM[M[_]](f: (CoalgebraOps[F, A]) ⇒ M[CoalgebraOps[F, A]])(implicit arg0: Monad[M], BF: Traverse[F]): M[CoalgebraOps[F, A]]

def
transFutu[U, G[_]](f: CoalgebraicGTransform[[β$1$]Free[G, β$1$], CoalgebraOps[F, A], F, G])(implicit arg0: Functor[G], U: Aux[U, G], BF: Functor[F]): U

def
transGana[M[_], U, G[_]](k: DistributiveLaw[M, G], f: CoalgebraicGTransform[M, CoalgebraOps[F, A], F, G])(implicit arg0: Monad[M], arg1: Functor[G], U: Aux[U, G], BF: Functor[F]): U

def
transHylo[G[_], U, H[_]](φ: (G[U]) ⇒ H[U], ψ: (F[CoalgebraOps[F, A]]) ⇒ G[CoalgebraOps[F, A]])(implicit arg0: Functor[G], arg1: Functor[H], U: Aux[U, H], BF: Functor[F]): U


final
def
wait(): Unit

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

final
def
wait(arg0: Long): Unit

def
zygo[A, B](f: Algebra[F, B], g: GAlgebra[[β$41$](B, β$41$), F, A])(implicit BF: Functor[F]): A

def
zygoM[A, B, M[_]](f: AlgebraM[M, F, B], g: GAlgebraM[[β$42$](B, β$42$), M, F, A])(implicit arg0: Monad[M], BT: Traverse[F]): M[A]
Inherited by implicit conversion toMergeOps from
CoalgebraOps[F, A] to Ops[[A]CoalgebraOps[F, A], A] { type TypeClassType = matryoshka.Merge[[A]matryoshka.implicits.CoalgebraOps[F,A]] }