pretty printer for moonbit

pretty printer

utils

string

Download zip

Author

Yoorkin

Version

0.4.3

License

Apache-2.0

Repository

github.com/Yoorkin/prettyprinter

Last updated

last year

Downloads

No dependencies

#pretty printer

A declarative-style pretty printer engine, which includes printers for built-in types such as Array, Map, and JsonValue.

#Install

Add Yoorkin/prettyprinter as dependency by moon add.

Import package prettyprinter in moon.pkg.json, like this:

{
  "import": [
    "Yoorkin/prettyprinter"
  ]
}

#Usage

#Print Value

Use render to pretty print any type implemented Pretty trait.

let map = {
  "name": ["John", "Mike"], "age": ["15","18"], "id": ["11109121","2000012312"]
}
map |> @prettyprinter.render() |> println()

output:

{
  "name": ["John", "Mike"],
  "age": ["15", "18"],
  "id": ["11109121", "2000012312"]
}

#Implement Pretty Trait

Write declarative code to implement a printer for your type. See example in package prettyprinter/example.

Pretty

source

pub(open) trait Pretty {
  pretty(Self) -> Document
}

impl Pretty for Unit

impl Pretty for Bool

impl Pretty for Byte

impl Pretty for Char

impl Pretty for Int

impl Pretty for Int16

impl Pretty for Int64

impl Pretty for UInt

impl Pretty for UInt16

impl Pretty for UInt64

impl Pretty for Float

impl Pretty for Double

impl Pretty for String

impl Pretty for Option[A]

impl Pretty for Result[A, B]

fn pretty[A : Pretty, B : Pretty](res : Result[A, B]) -> Document

source

Pretty print a result value.

let ok : Result[Int, String] = Ok(100)
let err : Result[Int, String] = Err("error")
inspect!(pretty(ok), content="Ok(100)")
inspect!(pretty(err), content=
  #|Err("error")
)

impl Pretty for FixedArray[A]

fn pretty[A : Pretty](array : FixedArray[A]) -> Document

source

Pretty print a FixedArray

let x  : FixedArray[_] = [1, 2, 3]
inspect!(
  pretty(x),
  content="[1, 2, 3]",
)
inspect!(
  render(x, width=5),
  content=
    #|[
    #|  1,
    #|  2,
    #|  3
    #|]
  ,
)

impl Pretty for Bytes

fn pretty(bytes : Bytes) -> Document

source

Pretty print a Bytes

let x = Bytes::of([1,2,3,4,5])
inspect!(pretty(x), content="[b'\\x01', b'\\x02', b'\\x03', b'\\x04', b'\\x05']")
inspect!(
  render(x, width=15),
  content=
    #|[
    #|  b'\x01', b'\x02',
    #|  b'\x03', b'\x04',
    #|  b'\x05'
    #|]
  ,
)

impl Pretty for T

impl Pretty for Array[A]

impl Pretty for Iter[A]

impl Pretty for Iter2[A, B]

impl Pretty for Json

fn pretty(json : Json) -> Document

source

Pretty print a JSON value.

let user : Json = {
  "name": "John Doe",
  "age": 30,
  "is_student": false,
  "grades": [100, 90, 80],
  "address": { "street": "123 Main St", "city": "Springfield", "state": "IL" },
}
inspect!(
  pretty(user),
  content=
    #|{
    #|  "name": John Doe,
    #|  "age": 30,
    #|  "is_student": false,
    #|  "grades": [100, 90, 80],
    #|  "address": {"street": 123 Main St, "city": Springfield, "state": IL}
    #|}
  ,
)

impl Pretty for Map[A, B]

fn pretty[A : Pretty, B : Pretty](m : Map[A, B]) -> Document

source

Pretty print a map.

let score : Map[String, Int] = {
  "player1": 1009,
  "player2": 200,
  "player3": 30,
  "player4": 999999999,
  "player5": 999999999,
}
inspect!(
  pretty(score),
  content=
    #|{
    #|  "player1": 1009,
    #|  "player2": 200,
    #|  "player3": 30,
    #|  "player4": 999999999,
    #|  "player5": 999999999
    #|}
  ,
)

impl Pretty for T[A]

impl Pretty for T[A, B]

fn pretty[A : Pretty, B : Pretty](map : @moonbitlang/core/hashmap.T
T[A, B]) -> Document

source

Pretty print a @hashmap.T

let x = @hashmap.of([("key1",1),("key2",2000)])
inspect!(pretty(x), content=
  #|{"key2": 2000, "key1": 1}
)
inspect!(
  render(x, width=5),
  content=
    #|{
    #|  "key2": 2000,
    #|  "key1": 1
    #|}
  ,
)

impl Pretty for T[A]

fn pretty[A : Pretty](set : @moonbitlang/core/hashset.T
T[A]) -> Document

source

let x = @hashset.of(["key1","key2"])
inspect!(pretty(x), content=
  #|{"key1", "key2"}
)
inspect!(
  render(x, width=5),
  content=
    #|{
    #|  "key1",
    #|  "key2"
    #|}
  ,
)

impl Pretty for T[A]

impl Pretty for T[A, B]

impl Pretty for T[A]

impl Pretty for T[A]

fn pretty[A : Pretty](list : @moonbitlang/core/immut/list.T
T[A]) -> Document

source

Pretty print a @immut/list.T

let list = @immut/list.of([(1,'a'), (2,'b'), (3,'c')])
inspect!(pretty(list), content="[(1, a), (2, b), (3, c)]")
inspect!(render(list,width=10), content=
  #|[
  #|  (1, a),
  #|  (2, b),
  #|  (3, c)
  #|]
)

impl Pretty for T[A, B]

impl Pretty for T[A]

impl Pretty for T[A]

impl Pretty for T[A]

impl Pretty for Set[A]

fn pretty[A : Pretty](set : @moonbitlang/core/set.Set
Set[A]) -> Document

source

Pretty print a Set

let set = Set::of([1,2,3])
inspect!(pretty(set), content="{1, 2, 3}")
inspect!(
  render(set, width=5),
  content=
    #|{
    #|  1,
    #|  2,
    #|  3
    #|}
  ,
)

impl Pretty for T[A, B]

impl Pretty for T[A]

impl Pretty for Tuple2[A, B]

impl Pretty for Tuple3[A, B, C]

impl Pretty for Tuple4[A, B, C, D]

impl Pretty for Tuple5[A, B, C, D, E]

impl Pretty for Tuple6[A, B, C, D, E, F]

impl Pretty for Tuple7[A, B, C, D, E, F, G]

impl Pretty for Tuple8[A, B, C, D, E, F, G, H]

impl Pretty for Tuple9[A, B, C, D, E, F, G, H, I]

Document

source

type Document

impl Pretty for Document

impl Add for Document

impl Show for Document

Document::to_string

source

fn Document::to_string(self : Document) -> String

braces

source

fn braces(doc : Document) -> Document

wraps the given document in braces.

inspect!(braces(text("doc")), content="{doc}")

brackets

source

fn brackets(doc : Document) -> Document

wraps the given document in brackets.

inspect!(brackets(text("doc")), content="[doc]")

char

source

fn char(c : Char) -> Document

concat

source

fn concat(l : Document, r : Document) -> Document

Concatenate two documents. You can also use the + operator.

empty

source

let empty : Document

Empty document. render(empty) == ""

flow

source

fn flow(doc : Array[Document]) -> Document

print each documents in the same line if it fits, insert a line break otherwise.

let words = [
  "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog",
]
let doc = words.map(fn(x){text(x) + space}) |> flow()
inspect!(doc, content="The quick brown fox jumps over the lazy dog ")
inspect!(
  render(doc, width=10),
  content=
    #|The quick brown 
    #|fox jumps over 
    #|the lazy dog 
  ,
)

group

source

fn group(doc : Document) -> Document

group(doc) tries to render the doc on a single line, but if the doc doesn't fit, or contains a hardline, all the switch inside the doc will be rendered with the right document.

hardline

source

let hardline : Document

Force line break with current indentation. This document will always doesn't fit in the current line.

Example

render(text("hello") + nest(hardline + text("world")))
|> inspect!(
  content=
    #|hello
    #|  world
  ,
)

line

source

let line : Document

Represents a line break if the line is too long, or a space if it fits.

list

source

fn list(ls : Array[Document]) -> Document

Concatenate documents.

nest

source

fn nest(indent~ : Int = .., doc : Document) -> Document

Nest the document by n spaces. Any line breaks inside the nested document will be indented by n spaces.

parens

source

fn parens(doc : Document) -> Document

wraps the given document in parentheses.

inspect!(parens(text("doc")), content="(doc)")

pretty

source

fn pretty[A : Pretty](x : A) -> Document

render

source

fn render[A : Pretty](document : A, width~ : Int = ..) -> String

Renders a document as a pretty string with a specified width.

Arguments

x - The document to render.
width - The maximum width of the rendered string. Defaults to 80.

Returns

The rendered string.

separate

source

fn separate(sep : Document, docs : Array[Document]) -> Document

This function takes a separator document sep and an array of documents docs and returns a document where each document in the array is separated by the separator document.

Example

let sep = text("-")
let docs = [text("Hello"), text("World"), text("!")]
separate(sep, docs).pretty() |> inspect!(content="Hello-World-!")

separate_map

source

fn separate_map[A](sep : Document, elems : Array[A], f : (A) -> Document) -> Document

This function takes a separator document, an array of values, and a mapping function, and returns a document where each value in the array is mapped to a document using the mapping function, and then separated by the separator document.

Arguments

sep - The separator document to be used between each mapped value.
xs - The array of values to be mapped and separated.
f - The mapping function that takes a value from the array and returns a document.

Returns

The resulting document where each value is mapped and separated by the separator document.

Example

let doc = separate_map(text(","), [1,2,3], pretty)
inspect!(doc, content="1,2,3")

softline

source

let softline : Document

Represents a line break if the line is too long, or nothing if it fits.

space

source

let space : Document

Space character. render(space) == " "

string

source

fn string(str : String) -> Document

print the string with double quotes.

inspect!(string("Hello, World!"), content="\"Hello, World!\"")

surround

source

fn surround(left : Document, right : Document, doc : Document) -> Document

Surrounds the given document with the left and right documents.

surround(l, r, doc) is equivalent to l + doc + r

Example

inspect!(surround(char('['), char(']'), text("doc")), content="[doc]")

switch

source

fn switch(l : Document, r : Document) -> Document

Switch between two documents based on the available space. The left document represents the flatten mode, and the right one the pretty mode. If the left document fits, it will be rendered, otherwise the right one.

text

source

fn text(s : String) -> Document

to_string

source

fn to_string(self : Document) -> String

Source Files

Site source Report issue Packages Build queue Skills Statistics

prettyprinter

#pretty printer

#Install

#Usage

#Print Value

#Implement Pretty Trait

#Pretty

#Document

#Document::to_string

#braces

#brackets

#char

#concat

#empty

#flow

#group

#hardline

Example

#line

#list

#nest

#parens

#pretty

#render

Arguments

Returns

#separate

Example

#separate_map

Arguments

Returns

Example

#softline

#space

#string

#surround

Example

#switch

#text

#to_string

Source Files

Pretty

Document

Document::to_string

braces

brackets

char

concat

empty

flow

group

hardline

line

list

nest

parens

pretty

render

separate

separate_map

softline

space

string

surround

switch

text

to_string