RenderTree

Type Members

trait AllOps[A] extends Ops[A]
trait Ops[A] extends AnyRef
trait ToRenderTreeOps extends AnyRef

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
def apply[A](implicit instance: RenderTree[A]): RenderTree[A]

Annotations
@inline()
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit lazy val booleanRenderTree: RenderTree[slamdata.Predef.Boolean]

Definition Classes
RenderTreeInstances
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def cofree[F[_]](implicit F: Delay[RenderTree, F]): Delay[RenderTree, [β$5$]Cofree[F, β$5$]]

Definition Classes
RenderTreeInstances
implicit def const[A](implicit arg0: RenderTree[A]): Delay[RenderTree, [β$0$]Const[A, β$0$]]

Definition Classes
RenderTreeInstances
implicit def coproduct[F[_], G[_], A](implicit RF: RenderTree[F[A]], RG: RenderTree[G[A]]): RenderTree[Coproduct[F, G, A]]

Definition Classes
RenderTreeInstances
implicit def coproductDelay[F[_], G[_]](implicit RF: Delay[RenderTree, F], RG: Delay[RenderTree, G]): Delay[RenderTree, [γ$8$]Coproduct[F, G, γ$8$]]

Definition Classes
RenderTreeInstances
implicit def delay[F[_], A](implicit arg0: RenderTree[A], F: Delay[RenderTree, F]): RenderTree[F[A]]

Definition Classes
RenderTreeInstances
def delayFromShow[F[_]](implicit arg0: Functor[F], arg1: Foldable[F], F: Delay[Show, F]): Delay[RenderTree, F] { def apply[A](a: quasar.RenderTree[A]): quasar.RenderTree[F[A]] }
implicit lazy val doubleRenderTree: RenderTree[slamdata.Predef.Double]

Definition Classes
RenderTreeInstances
implicit def eitherRenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[\/[A, B]]

Definition Classes
RenderTreeInstances
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def fix[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Fix[F]]

Definition Classes
RenderTreeInstances0
implicit def free[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): Delay[RenderTree, [β$2$]Free[F, β$2$]]

Definition Classes
RenderTreeInstances
def fromShow[A](simpleType: slamdata.Predef.String)(implicit arg0: Show[A]): RenderTree[A]

Derive an instance from Show[A], with a static type; e.g.
Derive an instance from Show[A], with a static type; e.g. Shape(Circle(5)).
def fromShowAsType[A](parentType: slamdata.Predef.String)(implicit arg0: Show[A]): RenderTree[A]

Derive an instance from Show[A], where the result is one of a few choices, and suitable as the node's type; e.g.
Derive an instance from Show[A], where the result is one of a few choices, and suitable as the node's type; e.g. LeftSide. Note that the parentType is not shown in the usual text rendering.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit lazy val intRenderTree: RenderTree[slamdata.Predef.Int]

Definition Classes
RenderTreeInstances
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def leftTuple3RenderTree[A, B, C](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C]): RenderTree[((A, B), C)]

Definition Classes
RenderTreeInstances0
implicit def leftTuple4RenderTree[A, B, C, D](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C], RD: RenderTree[D]): RenderTree[(((A, B), C), D)]

Definition Classes
RenderTreeInstances
implicit def listMapRenderTree[K, V](implicit arg0: Show[K], RV: RenderTree[V]): RenderTree[slamdata.Predef.ListMap[K, V]]

Definition Classes
RenderTreeInstances
implicit def listRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.List[A]]

Definition Classes
RenderTreeInstances
def make[A](f: (A) ⇒ RenderedTree): RenderTree[A]
implicit def mu[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Mu[F]]

Definition Classes
RenderTreeInstances0
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
object nonInheritedOps extends ToRenderTreeOps
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def nu[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Nu[F]]

Definition Classes
RenderTreeInstances0
object ops
implicit def optionRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.Option[A]]

Definition Classes
RenderTreeInstances
implicit def pathRenderTree[B, T, S]: RenderTree[Path[B, T, S]]

Definition Classes
RenderTreeInstances
def print[A](label: slamdata.Predef.String, a: A)(implicit arg0: RenderTree[A]): slamdata.Predef.Unit

For use with <|, mostly.
def recursive[T, F[_]](implicit T: Aux[T, F], FD: Delay[RenderTree, F], FF: Functor[F]): RenderTree[T]
implicit def renderTreeT[T[_[_]], F[_]](implicit arg0: Functor[F], T: RenderTreeT[T], F: Delay[RenderTree, F]): RenderTree[T[F]]

Definition Classes
RenderTreeInstances
def simple[A](nodeType: slamdata.Predef.List[slamdata.Predef.String], f: (A) ⇒ slamdata.Predef.Option[slamdata.Predef.String]): RenderTree[A]

Always a Terminal, with a fixed type and computed label.
implicit lazy val stringRenderTree: RenderTree[slamdata.Predef.String]

Definition Classes
RenderTreeInstances
implicit lazy val symbolRenderTree: RenderTree[slamdata.Predef.Symbol]

Definition Classes
RenderTreeInstances
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toShow[A](implicit arg0: RenderTree[A]): Show[A]

Derive a Show[A] where RenderTree is defined.
def toString(): String

Definition Classes
AnyRef → Any
implicit def tuple2RenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[(A, B)]

Definition Classes
RenderTreeInstances1
implicit lazy val unit: RenderTree[slamdata.Predef.Unit]

Definition Classes
RenderTreeInstances
implicit def vectorRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.Vector[A]]

Definition Classes
RenderTreeInstances
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 Docs: trait RenderTree | package quasar

object RenderTree extends RenderTreeInstances with Serializable

Type Members

trait AllOps[A] extends Ops[A]

trait Ops[A] extends AnyRef

trait ToRenderTreeOps extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](implicit instance: RenderTree[A]): RenderTree[A]

final def asInstanceOf[T0]: T0

implicit lazy val booleanRenderTree: RenderTree[slamdata.Predef.Boolean]

def clone(): AnyRef

implicit def cofree[F[_]](implicit F: Delay[RenderTree, F]): Delay[RenderTree, [β$5$]Cofree[F, β$5$]]

implicit def const[A](implicit arg0: RenderTree[A]): Delay[RenderTree, [β$0$]Const[A, β$0$]]

implicit def coproduct[F[_], G[_], A](implicit RF: RenderTree[F[A]], RG: RenderTree[G[A]]): RenderTree[Coproduct[F, G, A]]

implicit def coproductDelay[F[_], G[_]](implicit RF: Delay[RenderTree, F], RG: Delay[RenderTree, G]): Delay[RenderTree, [γ$8$]Coproduct[F, G, γ$8$]]

implicit def delay[F[_], A](implicit arg0: RenderTree[A], F: Delay[RenderTree, F]): RenderTree[F[A]]

def delayFromShow[F[_]](implicit arg0: Functor[F], arg1: Foldable[F], F: Delay[Show, F]): Delay[RenderTree, F] { def apply[A](a: quasar.RenderTree[A]): quasar.RenderTree[F[A]] }

implicit lazy val doubleRenderTree: RenderTree[slamdata.Predef.Double]

implicit def eitherRenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[\/[A, B]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit def fix[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Fix[F]]

implicit def free[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): Delay[RenderTree, [β$2$]Free[F, β$2$]]

def fromShow[A](simpleType: slamdata.Predef.String)(implicit arg0: Show[A]): RenderTree[A]

def fromShowAsType[A](parentType: slamdata.Predef.String)(implicit arg0: Show[A]): RenderTree[A]

final def getClass(): Class[_]

def hashCode(): Int

implicit lazy val intRenderTree: RenderTree[slamdata.Predef.Int]

final def isInstanceOf[T0]: Boolean

implicit def leftTuple3RenderTree[A, B, C](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C]): RenderTree[((A, B), C)]

implicit def leftTuple4RenderTree[A, B, C, D](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C], RD: RenderTree[D]): RenderTree[(((A, B), C), D)]

implicit def listMapRenderTree[K, V](implicit arg0: Show[K], RV: RenderTree[V]): RenderTree[slamdata.Predef.ListMap[K, V]]

implicit def listRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.List[A]]

def make[A](f: (A) ⇒ RenderedTree): RenderTree[A]

implicit def mu[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Mu[F]]

final def ne(arg0: AnyRef): Boolean

object nonInheritedOps extends ToRenderTreeOps

final def notify(): Unit

final def notifyAll(): Unit

implicit def nu[F[_]](implicit arg0: Functor[F], F: Delay[RenderTree, F]): RenderTree[Nu[F]]

object ops

implicit def optionRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.Option[A]]

implicit def pathRenderTree[B, T, S]: RenderTree[Path[B, T, S]]

def print[A](label: slamdata.Predef.String, a: A)(implicit arg0: RenderTree[A]): slamdata.Predef.Unit

def recursive[T, F[_]](implicit T: Aux[T, F], FD: Delay[RenderTree, F], FF: Functor[F]): RenderTree[T]

implicit def renderTreeT[T[_[_]], F[_]](implicit arg0: Functor[F], T: RenderTreeT[T], F: Delay[RenderTree, F]): RenderTree[T[F]]

def simple[A](nodeType: slamdata.Predef.List[slamdata.Predef.String], f: (A) ⇒ slamdata.Predef.Option[slamdata.Predef.String]): RenderTree[A]

implicit lazy val stringRenderTree: RenderTree[slamdata.Predef.String]

implicit lazy val symbolRenderTree: RenderTree[slamdata.Predef.Symbol]

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

def toShow[A](implicit arg0: RenderTree[A]): Show[A]

def toString(): String

implicit def tuple2RenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[(A, B)]

implicit lazy val unit: RenderTree[slamdata.Predef.Unit]

implicit def vectorRenderTree[A](implicit RA: RenderTree[A]): RenderTree[slamdata.Predef.Vector[A]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from RenderTreeInstances

Inherited from RenderTreeInstances0

Inherited from RenderTreeInstances1

Inherited from AnyRef

Inherited from Any

Ungrouped