CrossClj

0.0.1 docs

SourceDocs



RECENT
    VARS
    ->map
    >>1
    anything
    anything-but
    both
    caseparse
    caseparse-noconsume
    choice+
    ckeof
    either+
    expect-several
    expect-specific
    expect-type
    expression
    flatten-1
    integer
    keyword
    keywords
    lift
    list
    make-container-parser
    make-type-matcher
    map
    maybe
    named
    parse1
    parseq
    parseq->map
    run-inferior
    string
    symbol
    symbols
    symbols-but
    token-by
    token-err
    token-err-by
    vector

    « Index of all namespaces of this project

    (->map p)
    Construct a single map from a sequence of named parsers.
    
    (anything-but & buts)
    (both p q)
    Parse p and then q, returning the results of both in order.
    
    (caseparse p cases)
    Run p, wrapped in a maybe, consuming input, and run one of the
    parsers in the cases map depending on p's result.
    (caseparse-noconsume p cases)
    Run p, wrapped in a maybe, without consuming input, and run one of
    the parsers in the cases map depending on p's output.
    (choice+ & parsers)
    Like choice, but try the nth parser even if the preceding parsers did consume input.
    
    (ckeof got f)
    (either+ p q)
    Like either, but try the second parser even if the first parser did consume input.
    
    (expect-several things)
    (expect-specific thing)
    (expect-type tname)
    (flatten-1 xs)
    (keyword)(keyword tok__55493__auto__)
    match any keyword (with no args) or a specific keyword
    
    (keywords & toks__55495__auto__)
    match any of several keywords
    
    (lift f p)
    (lift f p) -> (bind p (comp always f)
    
    (list)(list p__55573__auto__)
    match a list and run any provided parser on its contents
    
    macroPrivate
    (make-container-parser name preprocessor)
    macroPrivate
    (make-type-matcher name)
    (map)(map p__55573__auto__)
    match a map and run any provided parser on its contents
    
    (named name parser)
    (parse1 p p2)(parse1 p p2 & ps)
    Run a sequence of parsers, returning the result of the first parser.
    
    macro
    (parseq p)(parseq p q)(parseq p q & rs)
    Like >> for nxt. Expands into repeated both forms, flattened. (It will *parse* a *seq*uence.)
    
    macro
    (parseq->map & parsers)
    (run-inferior p input nesting)
    (symbol)(symbol tok__55493__auto__)
    match any symbol (with no args) or a specific symbol
    
    (symbols & toks__55495__auto__)
    match any of several symbols
    
    (symbols-but & syms)
    match any symbol but those provided as arguments
    
    (token-err f err)
    (token-err-by f err)
    (vector)(vector p__55573__auto__)
    match a vector and run any provided parser on its contents