org.intelligence.pretty

Package org.intelligence.pretty

Pretty printing combinators

Types

Ann	`interface Ann`
Annotated	`data class Annotated : Out`
Color	`data class Color`
D	`typealias D<A> = Pretty.() -> A`
Doc	`typealias Doc = D<Unit>`
Format	`class Format`
Out	`sealed class Out`
Pretty	`class Pretty`
Seq	`data class Seq : Out`
W	`typealias W = Int`

Functions

align	`fun <A> Pretty.align(body: D<A>): A`
annotate	`fun <A> Pretty.annotate(ann: Ann, body: D<A>): A`
bg	`fun <A> Pretty.bg(color: Color, bright: Boolean = false, f: D<A>): A`
black	`fun <A> Pretty.black(bright: Boolean = true, f: D<A>): A`
blue	`fun <A> Pretty.blue(bright: Boolean = true, f: D<A>): A`
bold	`fun <A> Pretty.bold(f: D<A>): A`
collection	`fun Pretty.collection(open: Doc, close: Doc, sep: Doc, vararg docs: Doc): Unit`
collectionBy	`fun <T> Pretty.collectionBy(by: Pretty.(T) -> Unit, open: Doc, close: Doc, sep: Doc, vararg docs: T): Unit`
cyan	`fun <A> Pretty.cyan(bright: Boolean = true, f: D<A>): A`
expr	`fun <A> Pretty.expr(d: D<A>): A`
fg	`fun <A> Pretty.fg(color: Color, bright: Boolean = true, f: D<A>): A`
green	`fun <A> Pretty.green(bright: Boolean = true, f: D<A>): A`
grouped	`fun <A> Pretty.grouped(body: D<A>): A`
guttered	`fun Pretty.guttered(t: String): Unit`
hsep	`fun Pretty.hsep(vararg docs: Doc): Unit`
hsepBy	`fun <T> Pretty.hsepBy(by: Pretty.(T) -> Unit, vararg docs: T): Unit`
hsepByTight	`fun <T> Pretty.hsepByTight(by: Pretty.(T) -> Unit, vararg docs: T): Unit`
hsepTight	`fun Pretty.hsepTight(vararg docs: Doc): Unit`
hvsep	`fun Pretty.hvsep(vararg docs: Doc): Unit`
hvsepBy	`fun <T> Pretty.hvsepBy(by: Pretty.(T) -> Unit, vararg docs: T): Unit`
hvsepByTight	`fun <T> Pretty.hvsepByTight(by: Pretty.(T) -> Unit, vararg docs: T): Unit`
hvsepTight	`fun Pretty.hvsepTight(vararg docs: Doc): Unit`
intersperse	`fun Pretty.intersperse(delim: Doc, vararg docs: Doc): Unit`
intersperseBy	`fun <T> Pretty.intersperseBy(by: Pretty.(T) -> Unit, delim: Doc, vararg docs: T): Unit`
italic	`fun <A> Pretty.italic(f: D<A>): A`
magenta	`fun <A> Pretty.magenta(bright: Boolean = true, f: D<A>): A`
nest	`fun <A> Pretty.nest(w: W, body: D<A>): A`
oxford	`fun Pretty.oxford(conjunction: String = "or", vararg docs: Doc): Unit`
oxfordBy	`fun <T> Pretty.oxfordBy(by: Pretty.(T) -> Unit = Pretty::simple, conjunction: String = "or", vararg docs: T): Unit`
red	`fun <A> Pretty.red(bright: Boolean = true, f: D<A>): A`
run	`fun <A> Pretty.run(d: D<A>): A`
simple	`fun Pretty.simple(t: Any?): Unit`
vsep	`fun Pretty.vsep(vararg docs: Doc): Unit`
vsepBy	`fun <T> Pretty.vsepBy(by: Pretty.(T) -> Unit, vararg docs: T): Unit`
white	`fun <A> Pretty.white(bright: Boolean = true, f: D<A>): A`
yellow	`fun <A> Pretty.yellow(bright: Boolean = true, f: D<A>): A`