prettyprinter
pretty printer for moonbit
pretty printer
format
utils
string
moon add Yoorkin/prettyprinter@0.4.10
Download zipAuthor
Version
0.4.10
License
Apache-2.0
Last updated
6 months ago
Downloads
5K
README#pretty printer
A declarative-style pretty printer engine, which includes printers for built-in
types such as Array, Map, and Json.
#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
impl Pretty for FixedArray[A]
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}
#|}
),
)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
#|}
),
)#Context
pub struct Context {
indent : Int
next_indent : Int
width : Int
}#Document
type Document#Requirement
pub(all) enum Requirement {
Space(Int)
Infinite
}impl Add for Requirementimpl Compare for Requirementimpl Eq for Requirementimpl Show for Requirementautomatically derived
#braces
wraps the given document in braces.
inspect(braces(text("doc")), content="{doc}")#brackets
wraps the given document in brackets.
inspect(brackets(text("doc")), content="[doc]")#concat
Concatenate two documents.
You can also use the + operator.
#ctor
Represent an enum value.
Example
let doc = ctor(pkg="pkg", ty="Enum", "Constr", [pretty(1), pretty(2)], labeled={
"loc": pretty(100),
"name": pretty("cons"),
})
inspect(
doc,
content=(
#|@pkg.Enum::Constr(1, 2, loc=100, name="cons")
),
)
let doc = ctor(
pkg="pkg",
ty="Enum",
"LongConstructor",
[
pretty(100000000),
pretty(200000000),
pretty(100000000),
pretty(200000000),
pretty(100000000),
pretty(200000000),
pretty(100000000),
pretty(200000000),
],
labeled={ "loc": pretty(100), "name": pretty("cons") },
)
inspect(
doc,
content=(
#|@pkg.Enum::LongConstructor(
#| 100000000,
#| 200000000,
#| 100000000,
#| 200000000,
#| 100000000,
#| 200000000,
#| 100000000,
#| 200000000,
#| loc=100,
#| name="cons",
#|)
),
)#flow
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
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
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
Represents a line break if the line is too long, or a space if it fits.
#mandatory_line
Ensures at least one line at this position.
inspect(
mandatory_line + nest(line + text("abc")),
content=(
#|
#| abc
),
)
inspect(
mandatory_line + nest(text("abc")),
content=(
#|
#|abc
),
)#mandatory_space
Inserts at least one space between concatenated text segments.
inspect(
text("f();") + mandatory_space + text("//todo"),
content="f(); //todo",
)
inspect(
text("f();") + space + mandatory_space + text("//todo"),
content="f(); //todo",
)
inspect(
text("f();") + hardline + mandatory_space + text("//todo"),
content=(
#|f();
#|//todo
),
)#nest
Nest the document by n spaces.
Any line breaks inside the nested document will be indented by n spaces.
#parens
wraps the given document in parentheses.
inspect(parens(text("doc")), content="(doc)")#record
Represent a struct.
Example
let doc = record(pkg="pkg", ty="Struct", {
"spos": pretty(1),
"epos": pretty(2),
"file": pretty("abc"),
})
inspect(
doc,
content=(
#|@pkg.Struct::{spos: 1, epos: 2, file: "abc"}
),
)
let doc = record(pkg="pkg", ty="Struct", {
"spos": pretty(1000000000),
"epos": pretty(2000000000),
"file": pretty("abc"),
"spos1": pretty(1000000000),
"epos1": pretty(2000000000),
"file1": pretty("abc"),
})
inspect(
doc,
content=(
#|@pkg.Struct::{
#| spos: 1000000000,
#| epos: 2000000000,
#| file: "abc",
#| spos1: 1000000000,
#| epos1: 2000000000,
#| file1: "abc",
#|}
),
)#render
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
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
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
Represents a line break if the line is too long, or nothing if it fits.
#string
print the string with double quotes.
inspect(string("Hello, World!"), content="\"Hello, World!\"")#surround
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
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.
#tuple
Represent a tuple.
Example
let doc = tuple([pretty(1), pretty('a'), pretty(true)])
inspect(doc, content="(1, a, true)")
let elem = pretty("very long string")
let doc = tuple(Array::make(5, elem))
inspect(
doc,
content=(
#|(
#| "very long string",
#| "very long string",
#| "very long string",
#| "very long string",
#| "very long string",
#|)
),
)pretty printer for moonbit
pretty printerformatutilsstring
0.4.10
Apache-2.0
Updated 6 months ago
5K downloads