std.block — xyz.zcaudate/std.block 4.0.6

block clj

(block elem)

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]"

block-children clj

(block-children block)

returns the children in the block

(->> (block-children (parse/parse-string "[1 2]")) (apply str)) => "1␣␣␣2"

block-height clj

(block-height block)

returns the height of a block

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

block-info clj

(block-info block)

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}

block-length clj

(block-length block)

return the length of the string

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

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

block-prefixed clj

(block-prefixed block)

returns the length of the starting characters

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

block-string clj

(block-string block)

returns block string as representated in the file

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

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

block-suffixed clj

(block-suffixed block)

returns the length of the ending characters

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

block-tag clj

(block-tag block)

returns block tag as keyword

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

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

block-type clj

(block-type block)

returns block type as keyword

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

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

block-value clj

(block-value block)

returns the value of the block

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

block-value-string clj

(block-value-string block)

returns the string for which a value will be generated

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

block-verify clj

(block-verify block)

checks that the block has correct data

block-width clj

(block-width block)

returns the width of a block

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

block? clj

(block? obj)

check whether an object is a block

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

(block? (construct/token "hello")) => true

comment clj

(comment s)

creates a comment block

(str (comment ";hello")) => ";hello"

comment-block? clj

(comment-block? block)

checks if the block is a token block

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

container clj

(container tag children)

creates a container

(str (container :list [(void) (void)])) => "( )"

container-block? clj

(container-block? block)

checks if block is a container block

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

contents clj

(contents block)

reads out the contents of a container

(contents (block [1 2 3])) => '[1 ␣ 2 ␣ 3]

cursor clj

(cursor)

creates a cursor for the navigator

(str (cursor)) => "|"

eof-block? clj

(eof-block? block)

checks if input is an eof block

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

expression? clj

(expression? block)

checks if the block has a value associated with it

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

linebreak-block? clj

(linebreak-block? block)

checks if block is of type :linebreak

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

linespace-block? clj

(linespace-block? block)

checks if block is of type :linespace

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

modifier-block? clj

(modifier-block? block)

checks if block is a modifier block

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

newline clj

(newline)

creates a newline

(str (newline)) => "
"

newlines clj

(newlines n)

creates multiple newlines

(apply str (newlines 5)) => "




"

parse-root clj

(parse-root s)

parses a root

(str (parse-root "a b c")) => "a b c"

parse-string clj

(parse-string s)

parses a block from a string input

(-> (parse-string "#(:b {:b 1})") (base/block-value)) => '(fn* [] ((keyword "b") {(keyword "b") 1}))

root clj

(root children)

constructs a root block

(str (root '[a b])) => "a b"

space clj

(space)

creates a space block

(str (space)) => "␣"

space-block? clj

(space-block? block)

checks if block is of type \space

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

spaces clj

(spaces n)

creates multiple space blocks

(apply str (spaces 5)) => "␣␣␣␣␣"

tab clj

(tab)

creates a tab

(str (tab)) => "\ "

tabs clj

(tabs n)

creates multiple tabs

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

token-block? clj

(token-block? block)

checks if the block is a token block

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

uneval clj

(uneval)

creates a hash-uneval block

(str (uneval)) => "#_"

void clj

(void)

(void ch)

creates a void block

(str (void)) => "␣"

void-block? clj

(void-block? block)

checks if the block is a void block

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