CrossClj

1.10.0-alpha4 docs

SourceDocs



RECENT
    VARS
    append-child
    branch?
    children
    down
    edit
    end?
    insert-child
    insert-left
    insert-right
    left
    leftmost
    lefts
    make-node
    next
    node
    path
    prev
    remove
    replace
    right
    rightmost
    rights
    root
    seq-zip
    up
    vector-zip
    xml-zip
    zipper

    « Index of all namespaces of this project

    Functional hierarchical zipper, with navigation, editing,
    and enumeration.  See Huet

    — Rich Hickey

    (append-child loc item)
    Inserts the item as the rightmost child of the node at this loc,
    without moving
    (branch? loc)
    Returns true if the node at loc is a branch
    
    (children loc)
    Returns a seq of the children of node at loc, which must be a branch
    
    (down loc)
    Returns the loc of the leftmost child of the node at this loc, or
    nil if no children
    (edit loc f & args)
    Replaces the node at this loc with the value of (f node args)
    
    (end? loc)
    Returns true if loc represents the end of a depth-first walk
    
    (insert-child loc item)
    Inserts the item as the leftmost child of the node at this loc,
    without moving
    (insert-left loc item)
    Inserts the item as the left sibling of the node at this loc,
    without moving
    (insert-right loc item)
    Inserts the item as the right sibling of the node at this loc,
    without moving
    (left loc)
    Returns the loc of the left sibling of the node at this loc, or nil
    
    (leftmost loc)
    Returns the loc of the leftmost sibling of the node at this loc, or self
    
    (lefts loc)
    Returns a seq of the left siblings of this loc
    
    (make-node loc node children)
    Returns a new branch node, given an existing node and new
    children. The loc is only used to supply the constructor.
    (next loc)
    Moves to the next loc in the hierarchy, depth-first. When reaching
    the end, returns a distinguished loc detectable via end?. If already
    at the end, stays there.
    (node loc)
    Returns the node at loc
    
    (path loc)
    Returns a seq of nodes leading to this loc
    
    (prev loc)
    Moves to the previous loc in the hierarchy, depth-first. If already
    at the root, returns nil.
    (remove loc)
    Removes the node at loc, returning the loc that would have preceded
    it in a depth-first walk.
    (replace loc node)
    Replaces the node at this loc, without moving
    
    (right loc)
    Returns the loc of the right sibling of the node at this loc, or nil
    
    (rightmost loc)
    Returns the loc of the rightmost sibling of the node at this loc, or self
    
    (rights loc)
    Returns a seq of the right siblings of this loc
    
    (root loc)
    zips all the way up and returns the root node, reflecting any
    changes.
    (seq-zip root)
    Returns a zipper for nested sequences, given a root sequence
    
    (up loc)
    Returns the loc of the parent of the node at this loc, or nil if at
    the top
    (vector-zip root)
    Returns a zipper for nested vectors, given a root vector
    
    (xml-zip root)
    Returns a zipper for xml elements (as from xml/parse),
    given a root element
    (zipper branch? children make-node root)
    Creates a new zipper structure. 
    
    branch? is a fn that, given a node, returns true if can have
    children, even if it currently doesn't.
    
    children is a fn that, given a branch node, returns a seq of its
    children.
    
    make-node is a fn that, given an existing node and a seq of
    children, returns a new branch node with the supplied children.
    root is the root node.