creates a block

(base/block-info (block 1)) => {:type :token, :tag :long, :string “1”, :height 0, :width 1}

(str (block 1 (newline) (void) 2)) => “1\n 2”

returns the children in the block

(->> (block-children (parse/parse-string “1 2”)) (apply str)) => “1␣␣␣2”

returns the height of a block

(block-height (construct/block ^:list (construct/newline) (construct/newline))) => 2

returns the data associated with the block

(block-info (construct/token true)) => {:type :token, :tag :boolean, :string “true”, :height 0, :width 4} => {:type :token, :tag :boolean, :string “true”}

(block-info (construct/void \tab)) => {:type :void, :tag :linetab, :string “\t”, :height 0, :width 4}

return the length of the string

(block-length (construct/void)) => 1

(block-length (construct/block 1 2 3 4)) => 9

returns the length of the starting characters

(block-prefixed (construct/block #{})) => 2

returns block string as representated in the file

(block-string (construct/token 3/4)) => “3/4”

(block-string (construct/void \space)) => ""

returns the length of the ending characters

(block-suffixed (construct/block #{})) => 1

returns block tag as keyword

(block-tag (construct/void nil)) => :eof

(block-tag (construct/void \space)) => :linespace

returns block type as keyword

(block-type (construct/void nil)) => :void

(block-type (construct/token “hello”)) => :token

returns the value of the block

(block-value (construct/token 1.2)) => 1.2

returns the string for which a value will be generated

(block-value-string (parse/parse-string “#(+ 1 ::2)”)) => “#(+ 1 (keyword ":2"))”

checks that the block has correct data

returns the width of a block

(block-width (construct/token ’hello)) => 5

check whether an object is a block

(block? (construct/void nil)) => true

(block? (construct/token “hello”)) => true

checks if a block can be representated as code

creates a comment block

(str (comment “;hello”)) => “;hello”

checks if the block is a token block

(comment-block? (construct/comment “;;hello”)) => true

creates a container

(str (container :list (void) (void))) => “( )”

checks if block is a container block

(container-block? (construct/block [])) => true

reads out the contents of a container

(contents (block 1 2 3)) => ’1 ␣ 2 ␣ 3

creates a cursor for the navigator

(str (cursor)) => “|”

checks if input is an eof block

(eof-block? (construct/void nil)) => true

checks if the block has a value associated with it

(expression? (construct/token 1.2)) => true

allow multiple passes to heal the delimiter

performs the main layout

checks if block is of type :linebreak

(linebreak-block? (construct/newline)) => true

checks if block is of type :linespace

(linespace-block? (construct/space)) => true

gets the max width of given block, along with starting offset

checks if block is a modifier block

(modifier-block? (construct/uneval)) => true

creates a newline

(str (newline)) => "
"

creates multiple newlines

(apply str (newlines 5)) => "




"

gets the first element in root

(str (parse-first “a b c”)) => “a”

parses a root

(str (parse-root “a b c”)) => “a b c”

parses a block from a string input

(-> (parse-string “#(:b {:b 1})”) (base/block-value)) => ’(fn* {(keyword “b”) 1}))

constructs a root block

creates a space block

(str (space)) => “␣”

checks if block is of type \space

(space-block? (construct/space)) => true

creates multiple space blocks

(apply str (spaces 5)) => “␣␣␣␣␣”

creates a tab

(str (tab)) => "\ "

creates multiple tabs

(apply str (tabs 5)) => "\ \ \ \ \ "

checks if the block is a token block

(token-block? (construct/token “hello”)) => true

creates a hash-uneval block

(str (uneval)) => “#_”

creates a void block

(str (void)) => “␣”

checks if the block is a void block

(void-block? (construct/void)) => true