cheshire/cheshire/GenTree

GenTree

sealed abstract class GenTree[+N, +L]
Companion:
object
class Object
trait Matchable
class Any
class Leaf[L]
class Node[N, L]

Value members

Abstract methods

def valueEither: Either[N, L]

Concrete methods

final def ===[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$30: Eq[N1], evidence$31: Eq[L1]): Boolean
final def bimap[N1, L1](f: N => N1, g: L => L1): GenTree[N1, L1]
final def bitraverse[F[_], N1, L1](f: N => F[N1], g: L => F[L1])(using evidence$25: Apply[F]): F[GenTree[N1, L1]]
final def button: Button[N, L]
final def isLeft[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$15: Eq[N1], evidence$16: Eq[L1]): Boolean
final def isLeftOf[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$17: Eq[N1], evidence$18: Eq[L1]): Boolean
final def isRight[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$19: Eq[N1], evidence$20: Eq[L1]): Boolean
final def isRightOf[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$21: Eq[N1], evidence$22: Eq[L1]): Boolean
final def leafCount: Int
final def nodeCount: Int
final def postOrder[F[_]](f: Button[N, L] => F[Unit])(using evidence$29: Monad[F]): F[Unit]
final def preOrder[F[_]](f: Button[N, L] => F[Unit])(using evidence$28: Monad[F]): F[Unit]
final def reducePostOrder[Z](f: L => Z)(g: (Z, Z, N) => Z): Z
final def reducePostOrderM[F[_], Z](f: L => F[Z])(g: (Z, Z, N) => F[Z])(using evidence$26: Monad[F]): F[Z]
final def scanPostOrder[Z](f: L => Z)(g: (Z, Z, N) => Z): GenTree[Z, Z]
final def scanPostOrderM[F[_], Z](f: L => F[Z])(g: (Z, Z, N) => F[Z])(using evidence$27: Monad[F]): F[GenTree[Z, Z]]
final def show[N1 >: N, L1 >: L](using evidence$32: Show[N1], evidence$33: Show[L1]): String
final def sibling[N1 >: N, L1 >: L](that: GenTree[N1, L1])(using evidence$23: Eq[N1], evidence$24: Eq[L1]): Option[GenTree[N1, L1]]
final def size: Int
final def startPostOrder: Button[N, L]
final def startPreOrder: Button[N, L]