CrossClj

0.4.7 docs

SourceDocs



RECENT
    VARS
    ->r
    accumulate-ll
    allow-one-line?
    any-zcoll?
    blanks
    body-map
    body-set
    c-r-pair
    cleave-end
    compare-keys
    compare-ordered-keys
    concat-no-nil
    concat-no-nil-alt
    concatv!
    conj-it!
    constant-pair
    contains-nil?
    count-constant-pairs
    dots
    expand-tabs
    find-what
    fit-within?
    fix-rightcnt
    fn-style->caller
    force-vector
    fzfit
    fzfit-one-line
    fzprint
    fzprint*
    fzprint-anon-fn
    fzprint-array
    fzprint-atom
    fzprint-binding-vec
    fzprint-dbg
    fzprint-extend
    fzprint-flow-seq
    fzprint-fn-obj
    fzprint-future-promise-delay-agent
    fzprint-hang
    fzprint-hang-one
    fzprint-hang-remaining
    fzprint-hang-unless-fail
    fzprint-inline-comments
    fzprint-justify-width
    fzprint-list
    fzprint-list*
    fzprint-map
    fzprint-map*
    fzprint-map-two-up
    fzprint-meta
    fzprint-ns
    fzprint-object
    fzprint-one-line
    fzprint-pairs
    fzprint-prefix*
    fzprint-reader-macro
    fzprint-record
    fzprint-seq
    fzprint-set
    fzprint-two-up
    fzprint-uneval
    fzprint-vec
    fzprint-vec*
    fzprint-wrap-comments
    generate-ll
    good-enough?
    hangflow
    hash-identity-str
    ignore-key-seq
    ignore-key-seq-silent
    in-hang
    indent
    internal-validate
    interpose-either
    interpose-either-nl-hf
    interpose-nl-hf
    keyword-fn?
    last-space
    lift-style-vec
    lift-vec
    line-count
    line-lengths
    line-lengths-iter
    line-widths
    loc-vec
    log-lines
    make-record
    map->r
    map-ignore
    max-width
    middle-element?
    next-space
    noarg1
    noarg1-map
    noarg1-set
    not-rightmost
    object-str?
    order-out
    pair-element?
    partition-all-2-nc
    partition-all-sym
    prefix-options
    prefix-tags
    remove-hangflow
    remove-key-seq
    remove-nl
    replace-color
    right-separator-map
    rightmost
    rstr-vec
    show-user-fn?
    showfn?
    single-line?
    split-lf
    split-lf-2
    str->key
    style-lines
    style-loc-vec
    wrap-comment
    wrap-zmap
    zat
    zcolor-map
    zpmap

    « Index of all namespaces of this project

    (->r left right)
    Positional factory function for class zprint.zprint.r.
    
    (accumulate-ll count-comment? [out cur-len just-eol? just-comment? :as in] s tag eol?)
    Take the vector carrying the intermediate results, and
    do the right thing with a new string. Vector is
    [ 0 out - vector accumulating line lengths 
      1 cur-len - length of current line
      just-eol? - did we just do an eol?
      ]
    s - string to add to current line
    tag - element type of string (comment's don't count in length)
    eol? - should we terminate line after adding count of s
    (allow-one-line? {:keys [fn-force-nl fn-gt2-force-nl fn-gt3-force-nl], :as options} len fn-style)
    Should we allow this function to print on a single line?
    
    (any-zcoll? options ind zloc)
    Return true if there are any collections in the collection.
    
    (blanks n)
    Produce a blank string of desired size.
    
    (c-r-pair commas? rightmost-pair? rightmost? options)
    Handle the complexity of commas and rightmost-pair with options.
    If it isn't a rightmost, it loses rightmost status.
    If it is a rightmost, and in the rightmost pair, it gain one rightmost
    since it has the right end thing (and we don't care about the comma).
    If it is the rightmost of the non-rightmost-pair, then the comma
    matters, and we handle that appropriately.  Whew!
    (cleave-end coll)
    Take a seq, and if it is contains a single symbol, simply return
    it in another seq.  If it contains something else, remove any non
    collections off of the end and return them in their own double seqs,
    as well as return the remainder (the beginning) as a double seq.
    (compare-keys x y)
    Do a key comparison that works well for numbers as well as
    strings.
    (compare-ordered-keys key-value zdotdotdot x y)
    Do a key comparison that places ordered keys first.
    
    (concat-no-nil & rest)
    Concatentate multiple sequences, but if any of them are nil or empty
    collections, return nil.
    (concat-no-nil-alt & rest)
    Concatentate multiple sequences, but if any of them are nil, return nil.
    This version is 15-20% slower than the version below. Keeping it around
    just for illustrative purposes.
    (concatv! v & rest)
    Given a transient vector v, concatenate all of the other
    elements in all of the remaining collections onto v.
    (conj-it! & rest)
    Make a version of conj! that take multiple arguments.
    
    (constant-pair caller {{:keys [constant-pair? constant-pair-min]} caller, :as options} seq-right)
    Argument is result of (zmap-right identity zloc), that is to say
    a seq of zlocs.  Output is a [pair-seq non-paired-item-count],
    if any.  If there are no pair-seqs, pair-seq must be nil, not
    an empty seq.
    (contains-nil? coll)
    Scan a collection, and return the number of nils or empty collections
    present (if any), and nil otherwise.
    (count-constant-pairs seq-right)
    Given a seq of zlocs, work backwards from the end, and see how
    many elements are pairs of constants (using zconstant?).  So that
    (... :a (stuff) :b (bother)) returns 4, since both :a and :b are
    zconstant? true. This is made more difficult by having to skip
    comments along the way as part of the pair check, but keep track
    of the ones we skip so the count is right in the end.  We don't
    expect any whitespace in this, because this seq should have been
    produced by zmap-right or its equivalent, which already skips the
    whitespace.
    (dots n)
    Produce a dot string of desired size.
    
    (expand-tabs tab-size s)(expand-tabs s)
    Takes a string, and expands tabs inside of the string based
    on a tab-size argument.
    (find-what style-vec)
    Given a style-vec, come up with a string that gives some hint of 
    where this style-vec came from.
    (fit-within? size coll depth)(fit-within? size coll)
    Take a size and a collection of vectors with two or more elements
    per vector.  The elements are zlocs, the vectors are not.  Return
    the remaining character count or nil if it for sure doesn't fit.
    In order to be sure it doesn't fit, this version doesn't assume
    *any* separators, so it really underestimates the size.
    (fix-rightcnt rightcnt)
    Handle issue with rightcnt.
    
    (force-vector coll)
    Ensure that whatever we have is a vector.
    
    (fzfit {:keys [width rightcnt dbg?], :as options} [line-count max-width :as style-lines-return])
    Given output from style-lines and options, see if it fits the width.  
    Return the number of lines it takes if it fits, nil otherwise.
    (fzfit-one-line options style-lines-return)
    Given the return from style-lines  and options, 
    return true if it fits on a single line.
    (fzprint options indent zloc)
    The pretty print part of fzprint.
    
    (fzprint* {:keys [width rightcnt fn-map hex? shift-seq dbg? dbg-print? in-hang? one-line? string-str? string-color depth max-depth trim-comments? in-code? max-hang-depth max-hang-span max-hang-count], :as options} indent zloc)
    The pretty print part of fzprint.
    
    (fzprint-anon-fn options ind zloc)
    Pretty print and focus style a fn element.
    
    (fzprint-array options ind zloc)
    (fzprint-atom {{:keys [object?]} :atom, :as options} ind zloc)
    (fzprint-binding-vec {{:keys [nl-separator?]} :binding, :as options} ind zloc)
    (fzprint-extend {{:keys [nl-separator?]} :extend, :as options} ind zloc)
    Print things with a symbol and collections following.  Kind of like with
    pairs, but not quite. This skips over zloc and does everything to the
    right of it!
    (fzprint-flow-seq options ind zloc-seq force-nl?)(fzprint-flow-seq options ind zloc-seq)
    Take a seq of a zloc, created by (zmap identity zloc) or
    and return a style-vec of the result.  Either it fits on one line, 
    or it is rendered on multiple lines.  You can force multiple lines 
    with force-nl?. If you want it to do less than everything in the 
    original zloc, modify the result of (zmap identity zloc) to just 
    contain what you want to print. ind is either a single indent,
    or a seq of indents, one for each element in zloc-seq.
    (fzprint-fn-obj {{:keys [object?]} :fn-obj, :as options} ind zloc)
    Print a function object, what you get when you put a function in
    a collection, for instance.  This doesn't do macros, you will notice.
    It also can't be invoked when zloc is a zipper.
    (fzprint-future-promise-delay-agent options ind zloc)
    Print out a future or a promise or a delay.  These can only be 
    sexpressions, since they don't exist in a textual representation 
    of code (or data for that matter).  That means that we can use 
    regular sexpression operations on zloc.
    (fzprint-hang {:keys [one-line?], :as options} caller hindent findent fzfn zloc-count zloc)
    Try to hang something and try to flow it, and then see which is
    better.  Has hang and flow indents. fzfn is the function to use 
    to do zloc.  Note what fzfn does with the input.  For instance,
    fzprint-pairs does a (zmap-right identity zloc).  Presumably the
    caller knows what the fzfn does, so it has to count the items
    itself and pass it in here as zloc-count if it isn't just (zcount zloc).
    (fzprint-hang-one caller {:keys [one-line?], :as options} hindent findent zloc)
    Try out the given zloc, and if it fits on the current line, just
    do that. It might fit on the same line, as this may not be the rest
    of the list that we are printing. If not, check it out with good-enough?
    and do the best you can.  Three choices, really: fits on same line, 
    does ok as hanging, or better with flow. hindent is hang-indent, and 
    findent is flow-indent, and each contains the initial separator.  
    Might be nice if the fn-style actually got sent to this fn.
    (fzprint-hang-remaining caller {:keys [dbg? width], {:keys [hang? constant-pair? constant-pair-min hang-avoid hang-expand hang-diff nl-separator?]} caller, :as options} hindent findent zloc fn-style zloc-count)(fzprint-hang-remaining caller options hindent findent zloc fn-style)
    zloc is already down inside a collection, it is not the collection
    itself. Operate on what is to the right of zloc.  We already know
    that the given zloc won't fit on the current line. [Besides, we
    ensure that if there are two things remaining anyway. ???] So
    now, try hanging and see if that is better than flow.  Unless
    :hang? is nil, in which case we will just flow.  hindent is
    hang-indent, and findent is flow-indent. This should never be
    called with :one-line because this is only called from fzprint-list*
    after the one-line processing is done. If the hindent equals the
    flow indent, then just do flow.  Do only zloc-count non-whitespace
    elements of zloc.
    (fzprint-hang-unless-fail options hindent findent fzfn zloc)
    Try to hang something and if it doesn't hang at all, then flow it,
    but strongly prefer hang.  Has hang and flow indents, and fzfn is the
    fzprint-? function to use with zloc.  Callers need to know whether this
    was hang or flow, so it returns [{:hang | :flow} style-vec] all the time.
    (fzprint-inline-comments {:keys [width], :as options} style-vec)
    Try to bring inline comments back onto the line on which they belong.
    
    (fzprint-justify-width caller {{:keys [justify?]} caller, :as options} ind coll)
    Figure the width for a justification of a set of pairs in coll.  
    Also, decide if it makes any sense to justify the pairs at all.
    For instance, they all need to be one-line.
    (fzprint-list options ind zloc)
    Pretty print and focus style a :list element.
    
    (fzprint-list* caller l-str r-str {:keys [fn-map user-fn-map one-line? fn-style no-arg1? fn-force-nl], {:keys [indent-arg indent]} caller, :as options} ind zloc)
    Print a list, which might be a list or an anon fn.  
    Lots of work to make a list look good, as that is typically code. 
    Presently all of the callers of this are :list.
    (fzprint-map options ind zloc)
    Format a real map. ONLY WORKES ON STRUCTURES AT PRESENT
    
    (fzprint-map* caller l-str r-str {:keys [one-line? ztype map-depth in-code?], {:keys [comma? key-ignore key-ignore-silent nl-separator? force-nl? lift-ns? lift-ns-in-code?]} caller, :as options} ind zloc)
    (fzprint-map-two-up caller {{:keys [justify? force-nl?]} caller, :keys [width rightcnt one-line? parallel?], :as options} ind commas? coll)
    Accept a sequence of pairs, and map fzprint-two-up across those pairs.
    If you have :one-line? set, this will return nil if it is way over,
    but it can't accurately tell exactly what will fit on one line, since
    it doesn't know the separators and such.  So, :one-line? true is a
    performance optimization, so it doesn't do a whole huge map just to
    find out that it could not possibly have fit on one line.  So, this
    returns a sequence of style-vecs, where the indentation for the
    stuff inside of the pairs is already there, but the separators of
    the style-vecs (including indentation and commas) is done by the
    caller of fzprint-map-two-up. Always returns a sequence of vector pairs:
    [[:hang <style-vec-for-one-pair>] [:flow <style-vec-for-one-pair>] ...].
    If you want a style vec instead, call remove-hangflow on the return 
    from fzprint-map-two-up.  This will use one-line?, but not check to see
    that it actually fits.  If you care about that, then you should check the
    return yourself.  It will, however, make an estimate of whether or not
    it will fit and if it clearly doesn't, it will return a nil.
    (fzprint-meta options ind zloc)
    Print the two items in a meta node.  Different because it doesn't print
    a single collection, so it doesn't do any indent or rightmost.  It also
    uses a different approach to calling fzprint-flow-seq with the
    results zmap, so that it prints all of the seq, not just the rightmost.
    (fzprint-ns options ind zloc)
    (fzprint-object options ind zloc zloc-value)(fzprint-object options ind zloc)
    Print something that looks like #object[...] in a way
    that will acknowledge the structure inside of the [...]
    (fzprint-one-line options ind zloc)
    Do a fzprint-seq like thing, but do it incrementally and
    if it gets too big, return nil.
    (fzprint-pairs {{:keys [nl-separator?]} :pair, :as options} ind zloc)
    Always prints pairs on a different line from other pairs.
    
    (fzprint-prefix* options ind zloc l-str)
    Print the single item after a variety of prefix characters.
    
    (fzprint-reader-macro options ind zloc)
    Print a reader-macro, often a reader-conditional. Adapted for differences
    in parsing #?@ between rewrite-clj and rewrite-cljs.  Also adapted for
    the rewrite-clj not parsing namespaced maps in the version presently
    used.
    (fzprint-record {{:keys [record-type? to-string?]} :record, :as options} ind zloc)
    (fzprint-seq {:keys [max-length], :as options} ind zloc-seq)
    Take a seq of a zloc, created by (zmap identity zloc) when zloc
    is a collection, or (zmap-right identity zloc) when zloc is already
    inside of a collection, and return a seq of the fzprint* of each 
    element.  No spacing between any of these elements. Note that this
    is not a style-vec, but a seq of style-vecs of each of the elements.
    These would need to be concatenated together to become a style-vec.
    ind is either a constant or a seq of indents, one for each element in
    zloc-seq.
    (fzprint-set options ind zloc)
    Pretty print and focus style a :set element.
    
    (fzprint-two-up caller {:keys [one-line? dbg? dbg-indent in-hang? do-in-hang? map-depth], {:keys [hang? dbg-local? dbg-cnt? indent indent-arg flow? key-color key-depth-color key-value-color]} caller, :as options} ind commas? justify-width rightmost-pair? [lloc rloc xloc :as pair])
    Print a single pair of things (though it might not be exactly a
    pair, given comments and :extend and the like), like bindings in
    a let, clauses in a cond, keys and values in a map.  Controlled
    by various maps, the key of which is caller.  This will return a
    style-vec (or nil), unless hangflow? is true, in which case it
    will return [:hang <style-vec>] or [:flow <style-vec>] so that
    the upstream folks know whether this was a hang or flow and can
    do the right thing based on that.
    (fzprint-uneval options ind zloc)
    Trim the #_ off the front of the uneval, and try to print it.
    
    (fzprint-vec options ind zloc)
    (fzprint-vec* caller l-str r-str {:keys [rightcnt in-code?], {:keys [wrap-coll? wrap? binding? option-fn-first respect-nl? sort? sort-in-code?]} caller, :as options} ind zloc)
    Print basic stuff like a vector or a set.  Several options for how to
    print them.
    (fzprint-wrap-comments {:keys [width], :as options} style-vec)
    Take the final output style-vec, and wrap any comments which run over
    the width. Looking for 
    (generate-ll count-comment? [out cur-len just-eol? just-comment? :as in] [s _ tag :as element])
    (good-enough? caller {:keys [width rightcnt dbg?], {:keys [hang-flow hang-type-flow hang-flow-limit general-hang-adjust hang-if-equal-flow?]} :tuning, {:keys [hang-expand hang-diff hang-size hang-adjust]} caller, :as options} fn-style p-count indent-diff [p-lines p-maxwidth p-length-seq p-what] [b-lines b-maxwidth _ b-what])
    Given the fn-style, is the first output good enough to be worth
    doing. p is pretty, which is typically hanging, and b is basic, which
    is typically flow. p-count is the number of elements in the hang.
    (hangflow hangflow? hang-or-flow style-vec)
    Take a style-vec, and if hangflow? is true, return a
    vector [hang-or-flow style-vec], else return style-vec.
    But a nil style-vec returns nil.
    (hash-identity-str obj)
    Find the hash-code identity for an object.
    
    (ignore-key-seq m ks)
    Given a map and a key sequence, remove that key sequence if
    it appears in the map leaving behind a key :zprint-ignored, 
    and terminate the reduce if it changes the map.
    (ignore-key-seq-silent m ks)
    Given a map and a key sequence, remove that key sequence if
    it appears in the map, and terminate the reduce if it changes
    the map.
    (in-hang options)
    Add :in-hang? true to the options map.
    
    (indent)
    error
    
    (internal-validate options error-str)
    Validate an options map that was returned from some internal configuration
    expression or configuration.  Either returns the options map or throws
    an error.
    (interpose-either sep-true sep-nil pred? coll)
    Do the same as interpose, but different seps depending on pred?.
    
    (interpose-either-nl-hf sep-true sep-true-nl sep-nil sep-nil-nl {:keys [nl-separator? nl-separator-flow?], :as suboptions} pred-fn coll)
    Do the same as interpose, but different seps depending on pred-fn
    return and nl-separator?.
    (interpose-nl-hf suboptions ind coll)
    Put a single or double line between pairs returned from fzprint-map-two-up.
    The first argument is the map resulting from (:map options) or (:pair options)
    or whatever.  It should have :nl-separator? and :nl-separator-flow? in it.
    (keyword-fn? options s)
    Takes a string, and returns the fn-style if it is a keyword and
    without the : it can be found in the fn-map.
    (last-space s from-index)
    Take a string and an index, and look for the last space prior to the
    index. If we wanted to tie ourselves to 1.8, we could use 
    clojure.string/last-index-of, but we don't.  However, we use similar
    conventions, i.e., if no space is found, return nil, and if the index
    is a space return that value, and accept any from-index, including one
    larger than the length of the string.
    (lift-style-vec style-vec)
    Take a style-vec [[s color type] [s color type] [[s color type]
    [s color type]] [s color type] ...] and lift out the inner vectors.
    (lift-vec out-vec element)
    Take a transient output vector and a vector and lift any style-vec elements
    out of the input vector.
    (line-count s)
    Count lines in a string.
    
    (line-lengths options ind style-vec)
    Take a style-vec, and output a sequence of numbers, one for each
    line, which contains the actual length. Must take the current
    indent to have a prayer of getting this right, but it is used
    only for the first line.  The ind can be an integer or a seq of
    integers, in which case only the first integer is used. Newlines
    can come anywhere in an element in a style-vec, it will account
    for both sides.  Will break lines on comments even if no newlines
    in them.  This doesn't count the length of comment lines unless
    [:comment :count?] is true, so that we don't format based on
    comment size -- that is handled with the wrap-comments at the
    end. Note that only vectors with :whitespace or :indent are scanned
    for newlines, and if consecutive newlines appear, only the first
    is counted as a newline -- the second is counted as a regular 
    character.
    (line-lengths-iter options ind style-vec)
    Take a style-vec, and output a sequence of numbers, one for each
    line, which contains the actual length. Must take the current
    indent to have a prayer of getting this right, but it is used
    only for the first line.  The ind can be an integer or a seq of
    integers, in which case only the first integer is used. Newlines
    can come anywhere in an element in a style-vec, it will account
    for both sides.  Will break lines on comments even if no newlines
    in them.  This doesn't count the length of comment lines unless
    [:comment :count?] is true, so that we don't format based on
    comment size -- that is handled with the wrap-comments elsewhere.
    Note that only vectors with :whitespace, :indent, or :newline are scanned
    for newlines, and if consecutive newlines appear, only the first
    is counted as a newline -- the second is counted as a regular 
    character. A single comment is counted as two lines. Lots of edge
    conditions that are really quite important.
    (line-widths s)
    Return a vector the lengths of lines.
    
    (loc-vec start [s])
    Takes the start of this vector and the vector itself.
    
    (log-lines {:keys [dbg-print? dbg-indent in-hang?], :as options} dbg-output ind style-vec)
    Accept a style-vec that we are about to hand to style-lines, and
    output it if called for, to aid in debugging.
    (make-record l r)
    (map->r m__7585__auto__)
    Factory function for class zprint.zprint.r, taking a map of keywords to field values.
    
    (map-ignore caller {{:keys [key-ignore key-ignore-silent]} caller, :as options} zloc)
    Take a map and remove any of the key sequences specified from it.
    Note that this only works for sexpressions, not for actual zippers.
    (max-width s)
    Split a string into lines, and figure the max width.
    
    (middle-element? {:keys [in-code?], :as options} zloc)
    This checks to see if an element should be considered the middle element
    of a pair.  At some point, we can expand this, but for now there is only
    one middle element.
    (next-space s from-index)
    Take a string and an index, and look for the next space *after* the
    index. If no space is found, return nil. Accept any from-index, 
    including one larger than the length of the string.
    (noarg1 options fn-type)
    Set noarg1 in the options if it is the right fn-type.
    
    (not-rightmost options)
    Remove the rightmost count.
    
    (object-str? s)
    Return true if the string starts with #object[
    
    (order-out caller {{:keys [sort? sort-in-code? key-order key-value]} caller, :keys [in-code?], :as options} access out)
    A variety of sorting and ordering options for the output of
    partition-all-2-nc.  It can sort, which is the default, but if
    the caller has a key-order vector, it will extract any keys in
    that vector and place them first (in order) before sorting the
    other keys.  If sorting is not called for, does nothing.
    (pair-element? zloc)
    This checks to see if an element should be considered part of a
    pair if it comes between other elements, and a single element on
    its own if it would otherwise be the first part of a pair.  Mostly
    this will trigger on comments, but a #_(...) element will also
    trigger this.
    (partition-all-2-nc {:as options, :keys [max-length]} coll)
    Input is (zseqnws zloc) where one assumes that these are pairs.
    Thus, a seq of zlocs.  Output is a sequence of seqs, where the
    seqs are usually pairs, but might be single things.  Doesn't pair
    up comments or #_(...) unevaled sexpressions.  The ones before
    the first part of a pair come as a single element in what would
    usually be a pair, and the ones between the first and second parts
    of a pair come inside the pair.  There may be an arbitrary number
    of elements between the first and second elements of the pair
    (one per line).  If there are any comments or unevaled sexpressions,
    don't sort the keys, as we might lose track of where the comments
    or unevaled s-expressions go.
    (partition-all-sym options modifier-set coll)
    Similar to partition-all-2-nc, but instead of trying to pair things
    up (modulo comments and unevaled expressions), this begins things
    with a symbol, and then accumulates collections until the next symbol.
    Returns a seq of seqs, where the first thing in each internal seq is
    a protocol and the remaining thing in that seq are the expressions that
    follow.  If there is a single thing, it is returned in its own internal
    seq. ((P (foo [this a) (bar-me [this] b) (barx [this y] (+ c y))) ...)
    Made harder by the fact that the symbol might be inside of a #?() reader
    conditional.  It handles comments before symbols on the symbol indent, 
    and the comments before the collections on the collection indent.  
    Since it doesn't know how many collections there are, this is not trivial.  
    Must be called with a sequence of z-things
    (prefix-options options prefix-tag)
    Change options as necessary based on prefix tag.
    
    (remove-hangflow hf-style-vec)
    Convert a hangflow style-vec to a regular style-vec.
    
    (remove-key-seq m ks)
    If given a non-collection, simply does a dissoc of the key, but
    if given a sequence of keys, will remove the final one.
    (remove-nl coll)
    Remove any [_ _ :newline] from the seq.
    
    (replace-color local-color style-vec)
    Given a style-vec with exactly one thing in it, replace the color
    with whatever local color we have determined is correct.
    (rightmost options)
    Increase the rightmost count, if any, and return one if not.
    
    (rstr-vec options ind zloc r-str r-type)(rstr-vec options ind zloc r-str)
    Create an r-str-vec with, possibly, a newline at the beginning if
    the last thing before it is a comment.
    (show-user-fn? options f)
    Show this thing as a user defined function?  Assumes that we
    have already handled any clojure defined functions!
    (showfn? fn-map f)
    Show this thing as a function?
    
    (single-line? style-vec)
    This looks at a style vec and doesn't do all that style-lines does.
    It just looks for a new-line in the strings, and returns true if it
    doesn't find one.
    (split-lf s)
    Do split for newlines, instead of using regular expressions.
    
    (split-lf-2 s)
    Do split for newlines, instead of using regular expressions.
    Maximum split is 2.
    (style-lines options ind style-vec)
    Take a style output, and tell us how many lines it takes to print it
    and the maximum width that it reaches. Returns 
    [<line-count> <max-width> [line-lengths]].
    Doesn't require any max-width inside the style-vec. Also returns the
    line lengths in case that is helpful (since we have them anyway).
    If (:dbg-ge options) has value, then uses find-what to see if what it
    finds matches the value, and if it does, place the value in the
    resulting vector.
    (style-loc-vec style-vec)
    Take a style-vec and produce a style-loc-vec with the starting column
    of each element in the style-vec.
    (wrap-comment width [s color stype :as element] start)
    If this is a comment, and it is too long, word wrap it to the right width.
    Note that top level comments may well end with a newline, so remove it
    and reapply it at the end if that is the case.
    (wrap-zmap caller {:keys [width rightcnt max-length], {:keys [wrap-after-multi?]} caller, :as options} ind coll-print)
    Given the output from fzprint-seq, which is a style-vec in
    the making without spacing, but with extra [] around the elements,
    wrap the elements to the right margin.
    (zat options value)
    Takes an option map and the return from zfuture.  If the
    options map has (:parallel? options) as true, then deref
    the value, otherwise just pass it through.
    (zcolor-map {:keys [color-map], :as options} key-or-str)
    Look up the thing in the zprint-color-map.  Accepts keywords or
    strings.
    (zpmap options f coll)(zpmap options f coll1 coll2)