CrossClj
full-text documentation search

Project count:
9877

Last update
Jun 16, 2018

How to be listed

Artifact list

Clojurescript

Feedback

RECENT
    Less more depended upon.
    Full-text search for function, var, namespace, project documentation and descriptions for Clojure open-source projects.
    Query syntax supports boolean modifiers (+word, -word), wildcards (* and ?, except for the first character of a word), and phrases ("word1 word2").
    To search for identifiers, use the name search.
    Found 479 results in 237 projects.
    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-DASHSourceDoc + Usages
    Split at `-` character.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-DOTSourceDoc + Usages
    Split at `.` character.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-DASH (cljs)SourceDoc + Usages
    Split at `-` character.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-DOT (cljs)SourceDoc + Usages
    Split at `.` character.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-DASHSourceDoc + Usages
    Split at `-` character.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-DOTSourceDoc + Usages
    Split at `.` character.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-DASH (cljs)SourceDoc + Usages
    Split at `-` character.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-DOT (cljs)SourceDoc + Usages
    Split at `.` character.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-DASHSourceDoc + Usages
    Split at `-` character.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-DOTSourceDoc + Usages
    Split at `.` character.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-DASH (cljs)SourceDoc + Usages
    Split at `-` character.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-DOT (cljs)SourceDoc + Usages
    Split at `.` character.

    funimage 0.1.90
    Functional Image Processing with ImageJ/FIJI
    funimage.imp/split-stackSourceDoc + Usages
    Split an imagestack.

    funimage 0.1.90
    Functional Image Processing with ImageJ/FIJI
    funimage.imp/split-channelsSourceDoc + Usages
    Split channels.

    curiosity.utils 0.9.3
    Misc clojure functions
    curiosity.utils/path-splitSourceDoc + Usages
    Split on / or nil

    swank-clj 0.1.6
    Another swank for clojure
    swank-clj.swank.core/linesSourceDoc + Usages
    Split a string in

    ritz-swank 0.7.0
    Swank server using ritz
    ritz.swank.core/linesSourceDoc + Usages
    Split a string in

    ritz 0.3.2
    Another swank server for clojure in SLIME
    ritz.swank.core/linesSourceDoc + Usages
    Split a string in

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/rest-split-at-pointsSourceDoc + Usages
    Split version string recursively at the given split points.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/rest-split-at-points (cljs)SourceDoc + Usages
    Split version string recursively at the given split points.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/rest-split-at-pointsSourceDoc + Usages
    Split version string recursively at the given split points.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/rest-split-at-points (cljs)SourceDoc + Usages
    Split version string recursively at the given split points.

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.commands.collections/splitSourceDoc + Usages
    split <pattern> <string> # split string with <pattern>

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/rest-split-at-pointsSourceDoc + Usages
    Split version string recursively at the given split points.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/rest-split-at-points (cljs)SourceDoc + Usages
    Split version string recursively at the given split points.

    fs 1.3.3
    File system utilities for clojure
    fs.core/splitSourceDoc + Usages
    Split path to components.

    noencore 0.3.4
    Clojure and ClojureScript fns not in core.
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.util/path-splitSourceDoc + Usages
    Split `s` at the file separator.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.fs.v1v4v6.me.raynes.fs/splitSourceDoc + Usages
    Split path to components.

    mranderson 0.4.8
    Leiningen plugin to download and use some dependencies as source.
    mranderson048.fs.v1v4v6.me.raynes.fs/splitSourceDoc + Usages
    Split path to components.

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.fs/make-pathSourceDoc + Usages
    The reverse of split-path

    milia 0.3.37
    The ona.io Clojure Web API Client.
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    sanity 1.12.0
    Fixes a number of problems with Clojure semantics and syntax and fills in some missing
    sanity.core/read-linesSourceDoc + Usages
    Read the file and split at newlines

    Split the string `s` by comma.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    cljs-ipfs-native 1.0.0
    Native ClojureScript js-ipfs-api implementation.
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    funimage 0.1.90
    Functional Image Processing with ImageJ/FIJI
    funimage.imp/split-rgbSourceDoc + Usages
    Split an RGB type image.

    bloomf 0.1.0
    Clojure BYOHF Bloom filter
    bloomf.core/shrinkSourceDoc + Usages
    Split the Bloom filter in half

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    cayenne 0.1.0
    Index and serve CrossRef metadata
    cayenne.data.funder/parse-query-termsSourceDoc + Usages
    Split query terms.

    anki-cljs 0.1.1
    CLJS interface for interacting with Anki
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    cmr-client 0.1.0
    A Clojure(Script) Client for NASA's Common Metadata Repository
    no.en.core/split-by-commaSourceDoc + Usages
    Split the string `s` by comma.

    lucid.distribute 1.4.6
    tools for code clarity
    lucid.distribute.split/split-scaffoldSourceDoc + Usages
    generates the scaffold for the split path

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-string (cljs)SourceDoc + Usages
    split sexp for "strings like this"

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-form (cljs)SourceDoc + Usages
    split sexp for (forms like this)

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-string (cljs)SourceDoc + Usages
    split sexp for "strings like this"

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-form (cljs)SourceDoc + Usages
    split sexp for (forms like this)

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cuerdas.core/charsSourceDoc + Usages
    Split a string in a seq of chars.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    no.en.core/split-by-comma (cljs)SourceDoc + Usages
    Split the string `s` by comma.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    no.en.core/split-by-comma (cljs)SourceDoc + Usages
    Split the string `s` by comma.

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-pargsoSourceDoc + Usages
    core.logic version of split-pargs

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-listoSourceDoc + Usages
    core.logic version of split-list

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-exproSourceDoc + Usages
    core.logic version of split-expr

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-pargsoSourceDoc + Usages
    core.logic version of split-pargs

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-listoSourceDoc + Usages
    core.logic version of split-list

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-exproSourceDoc + Usages
    core.logic version of split-expr

    cuerdas 0.3.2
    The missing string manipulation library for clojure
    cuerdas.core/chars (cljs)SourceDoc + Usages
    Split a string in a seq of chars.

    cuerdas 0.3.2
    The missing string manipulation library for clojure
    cuerdas.core/charsSourceDoc + Usages
    Split a string in a seq of chars.

    pdfboxing 0.1.13
    Clojure PDF manipulation library & wrapper for PDFBox
    pdfboxing.split/split-pdfSourceDoc + Usages
    split pdf into pages

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.zprint/split-lf-2SourceDoc + Usages
    Do split for newlines, instead of using regular expressions.
      Maximum split is 2.

    aerial.fs 1.1.5
    General file system utiltity functions
    aerial.fs/splitSourceDoc + Usages
    Split path to componenets.
    	(split "a/b/c") -> ("a" "b" "c")

    Splits a string on both ##( and #( using in-place-del-split and del-split

    noencore 0.3.4
    Clojure and ClojureScript fns not in core.
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    routes-clj 0.1.12
    A Clojure & ClojureScript routing library.
    routes.core/split-argsSourceDoc + Usages
    Split the `args` interpolation arguments and options.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    chimera 0.0.6
    Collection of useful Clojure(Script) functions.
    chimera.test-helpers/split-csvSourceDoc + Usages
    Split a CSV string's rows and columns

    clj-foundation 0.10.0
    Guiding opinions: Enhance the core language in resonable, useful, and conservative
    clj-foundation.math/INumberPartsSourceDoc + Usages
    A protocol for numbers that can be split into parts.

    Split the string `s` by the regex `pattern`.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    cljs-ipfs-native 1.0.0
    Native ClojureScript js-ipfs-api implementation.
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    tars 0.1.5
    CLI framework for Clojure.
    io.ryos.tars.repl/split-parametersSourceDoc + Usages
    Split parameters in form of command and parameters

    anki-cljs 0.1.1
    CLJS interface for interacting with Anki
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    circle-util 0.1.1
    FIXME: write description
    circle-util.fs/splitSourceDoc + Usages
    fs/split without using reflection

    cmr-client 0.1.0
    A Clojure(Script) Client for NASA's Common Metadata Repository
    no.en.core/split-by-regexSourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-sexp (cljs)SourceDoc + Usages
    paredit split-sexp exposed for keymap.

    paredit-cm 0.1.1
    paredit for codemirror
    paredit-cm.core/split-sexp (cljs)SourceDoc + Usages
    paredit split-sexp exposed for keymap.

    numberto 0.0.4
    numberto - all you need to play with numbers
    numberto.expression/tokenizeSourceDoc + Usages
    split expression into list of known tokens

    numberto 0.0.4
    numberto - all you need to play with numbers
    numberto.converters/num->digitsSourceDoc + Usages
    Split an integer number to the list of digits

    clash 1.4.1
    A clojure library that applies customizable structures to text files and quick
    clash.example.web_shop_example/load-weblogSourceDoc + Usages
    Load a resource into memory and split by lines

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    no.en.core/split-by-regex (cljs)SourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    no.en.core/split-by-regex (cljs)SourceDoc + Usages
    Split the string `s` by the regex `pattern`.

    like java split
         <return> vector

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-seq-matchersoSourceDoc + Usages
    core.logic version of split-seq-matchers

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.impl.matcher/split-seq-matchersoSourceDoc + Usages
    core.logic version of split-seq-matchers

    utilza 0.1.98
    ken's random utilities
    utilza.core/path-to-treeSourceDoc + Usages
    Split a path into a vector of parents and the node.

    flickr-clj 0.1.3
    A Clojure wrapper for the flickr API
    utils.string/splSourceDoc + Usages
    Split alias using to string cast.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    leiningen.ancient.cli/split-argsSourceDoc + Usages
    Split command line arguments into flags and rest arguments.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~$~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~$~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~ReduceContext~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~MapContext~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~nil~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~$~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splits~$~TupleSourceSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/splitsSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.source/-splitsSourceDoc + Usages
    Sequence of tuple sources for each split of original source.

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.commands.collections/wordsSourceDoc + Usages
    words <string> # split <string> by spaces into a list

    merkle-db-core 0.1.0
    Hybrid data store built on merkle trees.
    merkle-db.key/split-bytesSourceDoc + Usages
    Split a byte array into sections separated by 0x00 bytes.

    misaki 0.2.6.2-beta
    Jekyll inspired static site generator in Clojure
    misaki.util.string/str-split-lastSourceDoc + Usages
    Split string on a regular expression which matches at last.

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.zprint/max-widthSourceDoc + Usages
    Split a string into lines, and figure the max width.

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.zprint/split-lfSourceDoc + Usages
    Do split for newlines, instead of using regular expressions.

    re-view-routing 0.1.3
    ClojureScript routing tools
    re-view-routing.core/segments (cljs)SourceDoc + Usages
    Split route into segments, ignoring leading and trailing slashes.

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.fsp/split-ext+SourceDoc + Usages
    Split extension, grouping zipped extensions with rest of file

    ragtime.sql.files 0.4.0
    Ragtime adapter that reads migrations from SQL files.
    ragtime.sql.files/sql-statementsSourceDoc + Usages
    Split a SQL script into its component statements.

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-node~DataNode~INodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-node~IndexNode~INodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-nodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-node~DataNode~INodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-node~IndexNode~INodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    hitchhiker.tree.core/split-nodeSourceDoc + Usages
    Returns a Split object with the 2 nodes that we turned this into

    cljcav 0.1.1
    General library complementing clojure.core and cljs.core.
    cav.core/splitSourceDoc + Usages
    Split a coll into n pieces. The inverse of the interleave function.

    cljcav 0.1.1
    General library complementing clojure.core and cljs.core.
    cav.core/split (cljs)SourceDoc + Usages
    Split a coll into n pieces. The inverse of the interleave function.

    namejen 0.1.12
    A Markov-chain-based name generator for games, fiction, &c.
    namejen.sentences/string-tokensSourceDoc + Usages
      Split string on whitespace and remove extraneous empty strings.
      

    pdfsplit 0.4.0
    A Clojure library that splits and merges (multi-page) PDFs.
    pdfsplit.split/split-extSourceDoc + Usages
    split-ext returns a vector [root .ext] 

    clj-thamil 0.2.0
    A project encompassing various Thamil language-specific computing ideas
    clj-thamil.format/str->phonemesSourceDoc + Usages
    take a string and split it into its constitutent தமிழ் phonemes

    clj-egsiona 0.1.4
    A Clojure library for detecting locations in Norwegian texts
    clj-egsiona.country/county->tagsSourceDoc + Usages
    Takes the county split by #"[ ]" and find all occurences in tagged

    clj-cav 0.4.1
    DEPRECATED: A general library for Clojure and ClojureScript.
    cav.core/splitSourceDoc + Usages
    Split a coll into n pieces. The inverse of the interleave function.

    clj-cav 0.4.1
    DEPRECATED: A general library for Clojure and ClojureScript.
    cav.core/split (cljs)SourceDoc + Usages
    Split a coll into n pieces. The inverse of the interleave function.

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    rejax.core/wrap-handlers (cljs)SourceDoc + Usages
    Split xhr object into [response headers] for handlers.

    vector-ops 0.1.0
    Optimised vector operations
    vector-ops.core/splitv-atSourceDoc + Usages
    `clojure.core/split-at` but optimised for vectors. Returns a vector of vectors

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.formats.tcx/split-by-sportsSourceDoc + Usages
    Takes a multisport segment sequence and split it by sports

    numberto 0.0.4
    numberto - all you need to play with numbers
    numberto.solvers/permute-opsSourceDoc + Usages
    Generate all possible combinations of operations for current split

    numberto 0.0.4
    numberto - all you need to play with numbers
    numberto.solvers/valid-permute?SourceDoc + Usages
    Check whether generated code for split matches the rules

    sicmutils 0.10.0
    A port of the Scmutils computer algebra/mechanics system to Clojure
    sicmutils.calculus.derivative/with-and-without-tagSourceDoc + Usages
    Split the differential into the parts with and without tag and return the pair

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/statsSourceDoc + Usages
    Get training vs testing *dataset split* statistics.

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/lookupSourceDoc + Usages
    Returns the {"addr1" percent ...} listing for a given split

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/allSourceDoc + Usages
    List every split: {"split1" {"addr1" percent ...} ...}

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/lookup (cljs)SourceDoc + Usages
    Returns the {"addr1" percent ...} listing for a given split

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/all (cljs)SourceDoc + Usages
    List every split: {"split1" {"addr1" percent ...} ...}

    turbovote.imbarcode 0.1.6
    Generate USPS Intelligent Mail Barcodes
    turbovote.imbarcode/split-structure-digitsSourceDoc + Usages
    Split IMbarcode structure digits into their constituent parts

    imbarcode 1.0.1
    Generate USPS Intelligent Mail Barcodes
    imbarcode.core/split-structure-digitsSourceDoc + Usages
    Split IMbarcode structure digits into their constituent parts

    bio.io.vcf 0.1.0
    Library for working with VCF (Variant Call Format) files
    org.bioclojure.bio.io.vcf.parser-util/delimited-strSourceDoc + Usages
    Returns a parser that will split a string on the given `delim`. 

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/version->seqSourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/version->seq (cljs)SourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/version->seqSourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/version->seq (cljs)SourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/version->seqSourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/version->seq (cljs)SourceDoc + Usages
    Split version string using the given split points, creating a two-element vector
       representing a version/qualifiers pair.

    Split a string path into a vector of keywords.
      (split-path `Gene.organism.shortName`)
      => [:Gene :organism :shortName]

    Split a string path into a vector of keywords.
      (split-path `Gene.organism.shortName`)
      => [:Gene :organism :shortName]

    Split a string path into a vector of keywords.
      (split-path `Gene.organism.shortName`)
      => [:Gene :organism :shortName]

    cl-cronlike 0.0.2
    Cron-style scheduler for clojure
    cl-cronlike.core/split-or-splatSourceDoc + Usages
    For cron-like strings,  if the value is a splat (which is a *) then don't split
    it on commas. Otherwise, split the field on commas

    Given a string and two substrings, tries to split the string at the first
        occurence of the first substring, leaving that substring to the right of the
        split point. It then takes the right string and tries to split it on the second
        substring, this time leaving that second substring on the left of the split
        point.
    
        Ex. (three-split "test [test] test" "[" "]") => ["test " "[test]" " test"]
        

    Given a string and a substring, tries to split the string at the
        first occurance of the given substring, leaving that substring to the left
        of the split point
        
        Ex. (two-split-on-right "test-test" "-") => ["test-" "test"]
            (two-split-on-right "test-test-test" "-") => ["test-" "test-test"]
            (two-split-on-right "testtest" "-") => ["testtest" ""]
        

    Given a string and a substring, tries to split the string at the
        first occurance of the given substring, leaving that substring to the right
        of the split point
        
        Ex. (two-split-on-left "test-test" "-") => ["test" "-test"]
            (two-split-on-left "test-test-test" "-") => ["test" "-test-test"]
            (two-split-on-left "testtest" "-") => ["testtest" ""]
        

    pdfsplit 0.4.0
    A Clojure library that splits and merges (multi-page) PDFs.
    pdfsplit.split/splitSourceDoc + Usages
    Split splits pdfs into single pages.
      Split takes a path to a (multi-page) pdf, splits it into single pages,
      and saves the pages as PDF to disk. It returns a lazy seq of the split files.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/split-vecSourceDoc + Usages
    Split the given vector at the provided offsets using subvec. Supports negative offsets.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-COMPOUNDSourceDoc + Usages
    Split a given string into char-only and int-only parts.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/SPLIT-COMPOUND (cljs)SourceDoc + Usages
    Split a given string into char-only and int-only parts.

    Tests if symbol matches the prefix when symbol is split into parts on
      separator.

    selmer 1.11.7
    Django style templates for Clojure
    selmer.filter-parser/split-filter-valSourceDoc + Usages
    Split accessors like foo.bar.baz by the dot.
       But if there is a double dot '..' then it will leave it

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.utils/split-vecSourceDoc + Usages
    Split the given vector at the provided offsets using subvec. Supports negative offsets.

    compliment 0.3.6
    The Clojure completion library you deserve
    compliment.utils/fuzzy-matches?SourceDoc + Usages
    Tests if symbol matches the prefix when symbol is split into parts on
      separator.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-COMPOUNDSourceDoc + Usages
    Split a given string into char-only and int-only parts.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/SPLIT-COMPOUND (cljs)SourceDoc + Usages
    Split a given string into char-only and int-only parts.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.util/jser-spitSourceDoc + Usages
    Like `split`, but emits `content` to `f` via Java serialization.

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.util/split-kvsSourceDoc + Usages
    split into a nested list [[k v]] instead of a map so as to maintain the order

    misaki 0.2.6.2-beta
    Jekyll inspired static site generator in Clojure
    misaki.compiler.default.evaluator/split-into-def-and-bodySourceDoc + Usages
    Split s-exp into definition and template body using `def?`.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-COMPOUNDSourceDoc + Usages
    Split a given string into char-only and int-only parts.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/SPLIT-COMPOUND (cljs)SourceDoc + Usages
    Split a given string into char-only and int-only parts.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    refactor-nrepl.ns.slam.hound.search/path-entries-seqSourceDoc + Usages
    Split a string on the 'path separator', i.e. ':'. Used for splitting multiple
      classpath entries.

    lein-localrepo 0.5.4
    Leiningen local repository plugin
    leiningen.localrepo.internal/split-filenameSourceDoc + Usages
    Given a partial or complete file path, split into filename and extension and
      return as vector.

    clj-miscutil 0.5.0
    Miscellaneous utility functions/macros in Clojure
    clj-miscutil.core/split-filenameSourceDoc + Usages
    Given a partial or complete file path, split into filename and extension and
      return as vector.

    ego 0.1.9
    A library for working with a simple 'id' format.
    ego.core/id-numberSourceDoc + Usages
    Split the provided id and convert to a Long. Optionally, pass a function to validate the id.

    ego 0.1.9
    A library for working with a simple 'id' format.
    ego.core/split-id*SourceDoc + Usages
    Split an id on dash, returning the type as a string followed by the identifier.

    hiccup-find 1.0.0
    Hiccup tree inspection for tests
    hiccup-find.core/split-hiccup-symbolSourceDoc + Usages
    Split the hiccup 'tag name' symbol into the tag name, class names and id

    net 0.3.3-beta38
    A clojure netty companion
    net.transform.split/bytes-neededSourceDoc + Usages
    Figure out how many bytes need to be read to finish this split.

    net 0.3.3-beta38
    A clojure netty companion
    net.transform.split/payload-lengthSourceDoc + Usages
    Yield the length of the full split payload, this
         assumes header-length was called and returned.

    net 0.3.3-beta38
    A clojure netty companion
    net.transform.split/header-lengthSourceDoc + Usages
    Yield length of header needed to compute the length
         of the split, if possible.

    pcp-common 1.2.0
    Common protocol components for PCP
    puppetlabs.pcp.protocol/ExplodedUriSourceDoc + Usages
    Schema for PCP node Exploded Uri - an Uri split into the client and type components

    random-forests-clj 0.2.0
    An implementation of Random Forests for classification in Clojure
    random-forests.core/split-dataset-into-training-and-testSourceDoc + Usages
    splits a dataset into a training in test dataset using a 80/20 split

    pseudoace 0.5.7
    WormBase database migration library and CLI.
    pseudoace.ts-import/split-logs-to-dirSourceDoc + Usages
    Convert `objs` to log entries then spread them into .edn files
      split by date.

    plato 0.1.12
    Persists state to local storage.
    plato.core/split-key (cljs)SourceDoc + Usages
    Returns a list of keys as split from a nested key string.

    curiosity.utils 0.9.3
    Misc clojure functions
    curiosity.utils/csv-splitSourceDoc + Usages
    Split on commas or nil. For more complicated use cases, see clojure.data.csv

    bcbio.variation.recall 0.1.4
    Parallel merging, squaring off and ensemble calling for genomic variants.
    bcbio.variation.recall.merge/prep-by-regionSourceDoc + Usages
    General functionality to split a set of VCFs into regions and apply a function, in parallel, to each.

    circle-util 0.1.1
    FIXME: write description
    circle-util.seq/split-groupsSourceDoc + Usages
    Split a seq with the given predicate. The first value is the vector of positive results.

    sparse 0.1.3
    Generate sparse bit array representations of fundamental data types.
    sparse.utils/split-bitstringSourceDoc + Usages
    Split the bitstring 's' into a sequence of bitstrings of sizes defined in ranges 'r'.

    fnhouse 0.2.1-123541b
    Transform lightly-annotated functions into a full-fledged web service
    fnhouse.routes/split-pathSourceDoc + Usages
    Inputs: [path :- String]
      Returns: [String]
    
      Split a path into a sequence of segment tokens

    selmer-zuriar 1.0.5
    A clone with minor modification of https://github.com/yogthos/Selmer - all credit
    selmer.filter-parser/split-filter-valSourceDoc + Usages
    Split accessors like foo.bar.baz by the dot.
       But if there is a double dot '..' then it will leave it

    tick 0.3.5
    A Clojure library that deals with time
    tick.interval/group-segments-bySourceDoc + Usages
    Split the interval in to a lazy sequence of intervals, one for each
      local date.

    tick 0.3.5
    A Clojure library that deals with time
    tick.interval/segment-bySourceDoc + Usages
    Split the interval in to a lazy sequence of intervals, one for each
      local date.

    b-plus-tree 0.3.0
    A B+ Tree implemented in Clojure.
    b-plus-tree.core/split-root-nonleafSourceDoc + Usages
    Splits a :root-nonleaf node. Do not attempt to split another type of node.

    b-plus-tree 0.3.0
    A B+ Tree implemented in Clojure.
    b-plus-tree.core/split-root-leafSourceDoc + Usages
    Splits a :root-leaf node. Do not attempt to split another type of node.

    clj-duedil 0.4.4
    clj-duedil : a clojure library for the duedil api
    clj-duedil.impl/client-context-arglistSourceDoc + Usages
    split an arg-list with an optional client-context. returns
       [client-context arglist]

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/instance-countSourceDoc + Usages
    Get the number of total instances in the database.  This result is
      independent of the *dataset split* state.

    random-forests 0.1.0
    An implementation of Random Forests for classification in Clojure
    random-forests.core/split-dataset-into-training-and-testSourceDoc + Usages
    splits a dataset into a training in test dataset using a 80/20 split

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/save!SourceDoc + Usages
    Save the given set of splits and return {"split" {"addr1" percent ...}}

    bitsplit-core 0.1.17
    Provides the core functions and protocols necessary for a bitsplit implementation
    bitsplit.storage.protocol/save! (cljs)SourceDoc + Usages
    Save the given set of splits and return {"split" {"addr1" percent ...}}

    pedestal-content-negotiation 0.4.0
    Content negotiation for Pedestal web services.
    pedestal.content-negotiation/split-fnSourceDoc + Usages
    Returns a function that splits a string according to re, then trims
      and lowercases each split.

    simple-discord-client 0.2.5
    Simple Clojure discord client api, simple wrapper of discord Rest API.
    simple-discord.client/create-message-longSourceDoc + Usages
    Send long message, split message for up to 5 separated messages

    Returns a lazy sequence of RNG where each iteration is split from the
      previous.

    Returns a lazy sequence of RNG where each iteration is split from the
      previous.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/first-split-at-pointSourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.version-clj.v0v1v2.version-clj.split/first-split-at-point (cljs)SourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/first-split-at-pointSourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    version-clj 0.1.2
    Version Analysis and Comparison for Clojure
    version-clj.split/first-split-at-point (cljs)SourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/first-split-at-pointSourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.version-clj.v0v1v2.version-clj.split/first-split-at-point (cljs)SourceDoc + Usages
    Split using first split point. Creates a two-element vector consisting of the parts.
       The result should be interpreted as a version/qualifier data pair.

    hara.string.path 2.8.6
    patterns and utilities
    hara.string.path/splitSourceDoc + Usages
    splits a sequence of elements into a path seperated value
     
       (path/split :hello/world)
       => [:hello :world]
     
       (path/split "a/b/c/d")
       => '["a" "b" "c" "d"]

    hara 0.7.1
    Utilities library of Functions and Exploratory Programming
    hara.hash-map/keyword-splitSourceDoc + Usages
    The opposite of `keyword-join`. Splits a keyword
       by the `/` character into a vector of keys.
    
        (keyword-split :hello/there)
        ;=> [:hello :there]
    
        (keyword-split :a/b/c/d)
        ;=> [:a :b :c :d]
      

    hara.keyword 2.1.2
    General purpose utilities library
    hara.string.path/splitSourceDoc + Usages
    The opposite of `join`. Splits a keyword
       by the `/` character into a vector of keys.
    
        (keyword-split :hello/there)
        ;=> [:hello :there]
    
        (keyword-split :a/b/c/d)
        ;=> [:a :b :c :d]
      

    In string aware split
    
      Perform split at given position `pos` Like split, but:
    
      - if inside string splits string into two strings
    
      `pos` should provide `{:row :col }` which are relative to the start of the given form the zipper represents
      `zloc` must be positioned at a node previous (given depth first) to the node at given pos

    rewrite-cljs 0.4.4
    Comment-/Whitespace-preserving rewriting of EDN documents.
    rewrite-clj.paredit/split-at-pos (cljs)SourceDoc + Usages
    In string aware split
    
      Perform split at given position `pos` Like split, but:
    
      - if inside string splits string into two strings
    
      `pos` should provide `{:row :col }` which are relative to the start of the given form the zipper represents
      `zloc` must be positioned at a node previous (given depth first) to the node at given pos

    jai 0.2.12
    Manipulate source code like the DOM
    jai.query.compile/split-pathSourceDoc + Usages
    splits the path into up and down
      (split-path '[defn | if try] [1 :cursor])
      => '{:up (defn), :down [if try]}
    
      (split-path '[defn if try] [nil :cursor])
      => '{:up [], :down [defn if try]}

    lucid.query 1.4.6
    tools for code clarity
    lucid.query.compile/split-pathSourceDoc + Usages
    splits the path into up and down
       (split-path '[defn | if try] [1 :cursor])
       => '{:up (defn), :down [if try]}
     
       (split-path '[defn if try] [nil :cursor])
       => '{:up [], :down [defn if try]}

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/splitSourceDoc + Usages
    Behave as for split*, expecting predicates to be (where) expressions instead
      of functions. Example:
    
      ```clojure
      (split
        (< 0.9  metric) (with :state "critical" index)
        (< 0.75 metric) (with :state "warning" index)
        (with :state "ok" index))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/splitSourceDoc + Usages
    Behave as for split*, expecting predicates to be (where) expressions instead
      of functions. Example:
    
      ```clojure
      (split
        (< 0.9  metric) (with :state "critical" index)
        (< 0.75 metric) (with :state "warning" index)
        (with :state "ok" index))
      ```

    aerial.utils 1.2.0
    Utility 'tool belt' of functions for common tasks; trees; clustering; probability,
    aerial.utils.coll/splitv-atSourceDoc + Usages
    Eager split. Uses transducers to eagerly split a coll a pos n.
    
       WARNING: Uses eager drop - use with caution on large colls. Will
       infinite loop on infinite colls!
      

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/divide-by-foldSourceDoc + Usages
    Divide the data into folds and initialize the current fold in the *dataset
      split* state.  Using this kind of dataset split is useful for cross fold
      validation.
    
      * **folds** number of folds to use, which defaults to 10
    
      See [[set-fold]]

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.str-utils/re-splitSourceDoc + Usages
    Splits the string on instances of 'pattern'.  Returns a sequence of
      strings.  Optional 'limit' argument is the maximum number of
      splits.  Like Perl's 'split'.

    ring-core 1.7.0-RC1
    Ring core libraries.
    ring.middleware.nested-params/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    swank-clojure 1.4.3
    Swank server connecting Clojure to Emacs SLIME
    swank.commands.contrib.swank-c-p-c.internal/delimited-compound-prefix-match?SourceDoc + Usages
    Uses a delimiter as the `split' for a compound prefix match check.
      See also: `compound-prefix-match?'

    geom 1.0.0-RC3
    thi.ng geometry kit - meta project spec including all modules
    thi.ng.geom.mesh.ops/split-tfaceSourceDoc + Usages
    Takes a vertex, edge and face (triangle) to be split. Returns
      vector of 2 new faces.

    sparkling 2.1.3
    A Clojure Library for Apache Spark
    sparkling.ml.core/tv-handlerSourceDoc + Usages
    trains the data on a split (70%) of the data,
      and returns the metric scored on the remaining 30% of the data

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.adapters.irc/send-pasteSourceDoc + Usages
    In IRC there are new newlines. Each line must be sent as a separate message, so
       split it and send one for each

    lein-localrepo 0.5.4
    Leiningen local repository plugin
    leiningen.localrepo/split-artifactidSourceDoc + Usages
    Given 'groupIp/artifactId' string split them up and return
      as a vector of 2 elements.

    marginalia 0.9.1
    lightweight literate programming for clojure -- inspired by [docco](http://jashkenas.github.com/docco/)
    marginalia.latex/md->latexSourceDoc + Usages
    It applies pandoc in a string joined by `separator-marker`. The
      output is split using a regex created from `separator-marker`

    quil 2.7.1
    (mix Processing Clojure)
    quil.helpers.docs/wrap-linesSourceDoc + Usages
    Split a list of words in lists (lines) not longer than width chars each,
       space between words included.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.bootstrap3/form-horizontalSourceDoc + Usages
    Set up a container for labeled inputs (which should have :split) to render the labels beside the fields.

    ego 0.1.9
    A library for working with a simple 'id' format.
    ego.core/split-idSourceDoc + Usages
    Split an id on dash. Optionally pass a function (such as a set) that will be passed
       the id's type. If this function returns false, an error will be thrown.

    clj-obt 0.5.1
    Library for accessing the Oslo-Bergen-Tagger, and parsing of the output.
    clj-obt.tools/tag->sentenceSourceDoc + Usages
    Takes output from (split-sentences) and returns the sentence where the tagged word tag occurs.

    Split a key name on dots, and replace empty parts with an
      underscore. Returns a list of components.

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/partition-if (cljs)SourceDoc + Usages
    split coll where (pred elem next-elem) is true
        TODO good implementation :) 

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/partition-ifSourceDoc + Usages
    split coll where (pred elem next-elem) is true
        TODO good implementation :) 

    bartok-x 0.1
    a set of primitives for musical programming
    bartok.types-macros/rest-arg-helperSourceDoc + Usages
    manage rest argument and split types and args
          return [rest-arg? :boolean 
                  types-vec :vector
                  argv      :vector]

    formative 0.8.10-rc
    Web forms - rendering, parsing, and validating
    formative.util/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    maailma 1.1.0
    An opinionated configuration library
    maailma.core/->ksSourceDoc + Usages
    Normalize the string, split and map to keywords.
       Returns nil if the string doesn't match the app property prefix.

    random-forests-clj 0.2.0
    An implementation of Random Forests for classification in Clojure
    random-forests.core/determine-splitSourceDoc + Usages
    returns a feature value pair as {:feature feature, :value value} representing the best split of the provided examples from the provided features

    drift 1.5.3
    Drift is a rails like migration framework for Clojure.
    drift.args/split-argsSourceDoc + Usages
    split an arglist using a matcher fn : returns
       [args-before-match, args-including-and-after-match]

    honeysql-phoenix 0.2.1
    Clojure SQL for HBase Phoenix
    phoenix.honeysql/split-qual-colSourceDoc + Usages
    Split column name into tuple of [qual name], keywordized. Unqualified columns are
       grouped under :_.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    ring.middleware.nested-params/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    functional-vaadin 0.2.2
    A functional interface to Vaadin
    functional-vaadin.utils/humanizeSourceDoc + Usages
    Turn a keyword or symbol string into a humanized for. The text is split at hyphens (-) and each segment is capitalized

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.core/str->linesSourceDoc + Usages
    ***** DEPRECATED:  duplicate of str/split-lines *****
    
      Returns a lazy seq of lines from a string

    ish 0.1.1
    A Clojure library for approximate comparison of floating point numbers in tests.
    same.ish/split-floatsSourceDoc + Usages
    Split a collection into a vector of floating point values (of type Float or Double),
      and a set of all other values.

    routes 0.5.0
    URL-driven routes handling
    routes.core/split-pathSourceDoc + Usages
    Split the given path (usually a suffix) at the first slash, returning a
      vector of [part remainder], or return [path ""] if there is no slash

    vee 0.2.4
    Native Mobile Tooling for Clojure
    vee.ti/split-opts (cljs)SourceDoc + Usages
    Split passed options map into titanium-specific options, and vee
       specific options. Returns [vee-opts ti-opts].

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.str-utils/re-splitSourceDoc + Usages
    Splits the string on instances of 'pattern'.  Returns a sequence of
      strings.  Optional 'limit' argument is the maximum number of
      splits.  Like Perl's 'split'.

    node 0.0.1
    core.async flavored interface to a node standard library
    node.path/split (cljs)SourceDoc + Usages
    Returns the vector of path elements that constitute path
    
        (node.path/split "/Users/Clojure") ;=> ["" "Users" "Clojure"]

    vdd-core 0.1.2
    vdd-core is a minimal Clojure library built to help enable Visualization Driven
    vdd-core.main/parse-commandSourceDoc + Usages
    Parses an input line into a command. The input line is split on the first space. To the left of the
      space is the command. The right of the space is the data (if there is any).

    remix 0.0.4
    Mix and match machinery for web and sql.
    remix.middleware.nested-params/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    circle-util 0.1.1
    FIXME: write description
    circle-util.seq/distribute-keySourceDoc + Usages
    Split a seq of ints into n approximately-even seqs. Adds
      the next item into the coll with the lowest score

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    ring.middleware.nested-params/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    lucid.distribute 1.4.6
    tools for code clarity
    lucid.distribute.common/interim-pathSourceDoc + Usages
    shows the interim path where the files will be split
     
       (interim-path (project/project))
       ;;=> "<DIR>/lucidity/target/interim"
       

    lucid.distribute 1.4.6
    tools for code clarity
    lucid.distribute.manifest.source/split-pathSourceDoc + Usages
    splits the file into its path components
       
       (split-path "repack/example/hello.clj")
       =>  ["repack" "example" "hello"]

    lucid.distribute 1.4.6
    tools for code clarity
    lucid.distribute.split/splitSourceDoc + Usages
    splits up current project to put in the interim directory
              
       (split (project/project))
       ;;=> look in `target/interim` for changes
       

    clj-vat 0.1.2
    A Clojure(Script) library designed to validate European VAT code
    clj-vat.algo/split->numsSourceDoc + Usages
    Split une chaîne de chiffres à la position n en deux nombres.

    clj-vat 0.1.2
    A Clojure(Script) library designed to validate European VAT code
    clj-vat.algo/split->nums (cljs)SourceDoc + Usages
    Split une chaîne de chiffres à la position n en deux nombres.

    Uses a delimiter as the `split' for a compound prefix match check.
      See also: `compound-prefix-match?'

    Uses a delimiter as the `split' for a compound prefix match check.
      See also: `compound-prefix-match?'

    ltof 0.1.1
    Split one file into many via Clojure line to file api.
    ltof.core/ltofSourceDoc + Usages
    Split file f line by line into other files
       named by line-fn function.

    clj-cn-mmseg 0.1.5
    clj-cn-mmseg是一个用clojure实现的mmseg中文分词工具包。
    clj-cn-mmseg.core/mmseg-seg-onlySourceDoc + Usages
    Only return the segment result without additional information
    of the words. The result words is split by space.
    Type :: String -> String

    clj-cn-mmseg 0.1.5
    clj-cn-mmseg是一个用clojure实现的mmseg中文分词工具包。
    clj-cn-mmseg.dict/wikiper->perSourceDoc + Usages
    Change wikipedia per information, like drop disambiguation information,
    split of foreign names into chunks etc.

    histogram 4.1.3
    Streaming histograms for Clojure/Java
    bigml.histogram.core/uniformSourceDoc + Usages
    Returns the split points that would separate the histogram into
       the supplied number of bins with equal population.

    Uses a delimiter as the `split' for a compound prefix match check.
      See also: `compound-prefix-match?'

    Uses a delimiter as the `split' for a compound prefix match check.
      See also: `compound-prefix-match?'

    eat-static 0.1.0
    Eat Static, a library for type checking and validation of Clojure maps and functions.
    eat-static.validations/extract-non-nil-defaultsSourceDoc + Usages
    Given a vector of default values, as per arg-split, extract the symbols with non-nil defaults.

    ansi 0.1.4
    Parse ANSI color codes, optionally convert to Hiccup.
    lambdaisland.ansi/str-splitSourceDoc + Usages
    Like clojure.string/split, but uses a single character instead of a regex,
      allowing for faster operation.

    dogfort 0.2.1
    A web server framework for Clojurescript on Node
    dogfort.middleware.nested-params/nest-params (cljs)SourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    shopify 0.1.1
    A library for interacting with the Shopify platform.
    shopify.util/partition-keysSourceDoc + Usages
    Takes a map and a predicate and returns two maps split by which keys satisfy the predicate

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/clearSourceDoc + Usages
    Clear the in memory instance data.  If key `:wipe-persistent?` is `true` all
      fold and test/train split data is also cleared.

    random-forests 0.1.0
    An implementation of Random Forests for classification in Clojure
    random-forests.core/determine-splitSourceDoc + Usages
    returns a feature value pair as {:feature feature, :value value} representing the best split of the provided examples from the provided features

    formidable 0.1.10
    Web forms - rendering, parsing, and validating
    formidable.util/nest-paramsSourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    formidable 0.1.10
    Web forms - rendering, parsing, and validating
    formidable.util/nest-params (cljs)SourceDoc + Usages
    Takes a flat map of parameters and turns it into a nested map of
      parameters, using the function parse to split the parameter names
      into keys.

    card-shuffle 0.2.0
    Clojure implementation of many humanoid card shuffling techniques
    card-shuffle/pad-split-deckSourceDoc + Usages
    Helper methd to pad split decks so interleaves doesn't stop at smaller collection.

    clojure-polyline 0.1
    library to encode and decode google polyline algorithm
    clojure-polyline.core/partition-by-inclusiveSourceDoc + Usages
    like partition-by, but also puts the first non-matching element
      in the split, and only groups results that return true in the pred f

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicate-positionsSourceDoc + Usages
      Optimized version of `split-by-predicate` where we assume that the data is from a signal that we can sample.
    
      Instead of checking each element, we check 1 over `n` elements.
    
     We return the positions where the data splits.
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.001))]
        (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 10))
    ~~~
    
      The following assertion holds:
    
    ~~~clojure
      (= (split-by-predicate coll pred n)
         (map #(apply subsequence data %) (split-by-predicate-positions coll pred n 1)))
    ~~~
    
      Here is an example:
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.01))]
        (= (split-by-predicate data #(<= -0.01 % 0.01) 2)
           (map #(apply subsequence data %) (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 1))))
    ~~~
      

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicate-positionsSourceDoc + Usages
      Optimized version of `split-by-predicate` where we assume that the data is from a signal that we can sample.
    
      Instead of checking each element, we check 1 over `n` elements.
    
     We return the positions where the data splits.
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.001))]
        (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 10))
    ~~~
    
      The following assertion holds:
    
    ~~~clojure
      (= (split-by-predicate coll pred n)
         (map #(apply subsequence data %) (split-by-predicate-positions coll pred n 1)))
    ~~~
    
      Here is an example:
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.01))]
        (= (split-by-predicate data #(<= -0.01 % 0.01) 2)
           (map #(apply subsequence data %) (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 1))))
    ~~~
      

    swank-clojure 1.4.3
    Swank server connecting Clojure to Emacs SLIME
    swank.commands.contrib.swank-c-p-c.internal/compound-prefix-match?SourceDoc + Usages
    Takes a `prefix' and a `target' string and returns whether `prefix'
      is a compound-prefix of `target'.
    
      Viewing each of `prefix' and `target' as a series of substrings
      split by `split', if each substring of `prefix' is a prefix of the
      corresponding substring in `target' then we call `prefix' a
      compound-prefix of `target'.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.fn/initializeSourceDoc + Usages
    Enable function instrumentalization by registering the metric collectors.
       Metrics include:
    
       - `fn_duration_seconds`: a histogram of execution duration,
       - `fn_last_failure_unixtime`: a gauge with the last failure timestamp,
       - `fn_runs_total`: a counter for fn runs, split by success/failure,
       - `fn_exceptions_total`: a counter for fn exceptions, split by class.
       

    clojure.string/split is a wrapper on java.lang.String/split with the limit
       parameter equal to 0, which keeps leading empty strings, but discards
       trailing empty strings. This makes no sense, so we have to write our own
       to keep the trailing empty strings.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.tree/decision-treeSourceDoc + Usages
    Build a decision tree.
    
      - n-samples will be sampled with replacement from the samples X or the subset of X specified
      by passing sample-indices
      - n-features will be sampled from the columns of X or the specified feature-indices
      - the split-fn will be called with [X feature-indices] and it must return
        [feature-index rand-split]
      

    sparse 0.1.3
    Generate sparse bit array representations of fundamental data types.
    sparse.utils/split-bitstring-fnSourceDoc + Usages
    Function supports the splitting of a string into smaller strings. 'v' is a sequence
      of one or more strings where the last string is to be split into two strings, the first
      of length 'n'. The result returned is a sequence idential to the original sequence but
      with the last item split into two parts.

    Takes a `prefix' and a `target' string and returns whether `prefix'
      is a compound-prefix of `target'.
    
      Viewing each of `prefix' and `target' as a series of substrings
      split by `split', if each substring of `prefix' is a prefix of the
      corresponding substring in `target' then we call `prefix' a
      compound-prefix of `target'.

    Takes a `prefix' and a `target' string and returns whether `prefix'
      is a compound-prefix of `target'.
    
      Viewing each of `prefix' and `target' as a series of substrings
      split by `split', if each substring of `prefix' is a prefix of the
      corresponding substring in `target' then we call `prefix' a
      compound-prefix of `target'.

    b-plus-tree 0.3.0
    A B+ Tree implemented in Clojure.
    b-plus-tree.seq/split-centerSourceDoc + Usages
    Splits coll into 3 parts, with the center element being its own part.
      The first part is never larger than the last.
    
      Examples:
        > (split-center (range 5))
        [(0 1) 2 (3 4)]
    
        > (split-center (range 6))
        [(0 1) 2 (3 4 5)]

    Takes a `prefix' and a `target' string and returns whether `prefix'
      is a compound-prefix of `target'.
    
      Viewing each of `prefix' and `target' as a series of substrings
      split by `split', if each substring of `prefix' is a prefix of the
      corresponding substring in `target' then we call `prefix' a
      compound-prefix of `target'.

    Takes a `prefix' and a `target' string and returns whether `prefix'
      is a compound-prefix of `target'.
    
      Viewing each of `prefix' and `target' as a series of substrings
      split by `split', if each substring of `prefix' is a prefix of the
      corresponding substring in `target' then we call `prefix' a
      compound-prefix of `target'.

    psq.clj 0.0.2
    Persistent Priority Search Queues in Clojure
    psq.clj/splitSourceDoc + Usages
    Returns
    
        [left entry right].
    
      left and right are PSQs comprising the entries in the given PSQ whose keys
      are, respectively, < and > the given split key in the given PSQ's key
      ordering.
    
      entry is the entry at the split key if present in the given PSQ, otherwise
      nil.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/separateSourceDoc + Usages
    Split coll into two sequences, one that matches pred and one that doesn't. Unlike the
      version in clojure.contrib.seq-utils, pred is only called once per item.

    All the lexicographic distinct partitions of items.
        Optionally pass in :min and/or :max to specify inclusive bounds on the number of parts the items can be split into.

    Split current s-sexpression in two at given node `zloc`
    
      -  `[1 2 |3 4 5] => [1 2 3] [4 5]`

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.seq/separateSourceDoc + Usages
    Split coll into two sequences, one that matches pred and one that doesn't. Unlike the
      version in clojure.contrib.seq-utils, pred is only called once per item.

    hara.test 2.8.6
    patterns and utilities
    hara.test.form/collectSourceDoc + Usages
    makes sure that all returned verified results are true
       (->> (split '[(+ 1 1) => 2
                     (+ 1 2) => 3])
            (mapv process/process)
            (collect {}))
       => true

    merkle-db-core 0.1.0
    Hybrid data store built on merkle trees.
    merkle-db.index/child-boundariesSourceDoc + Usages
    Return a sequence of tuples of a child link, its leading boundary, and its
      trailing boundary, corresponding to the split keys on either side of that
      child.

    merkle-db-core 0.1.0
    Hybrid data store built on merkle trees.
    merkle-db.partition/from-recordsSourceDoc + Usages
    Constructs a new partition from the given map of record data. The records
      will be split into tablets matching the given families, if provided. Returns
      the node data for the persisted partition.

    lein-localrepo 0.5.4
    Leiningen local repository plugin
    leiningen.localrepo.internal/split-filepathSourceDoc + Usages
    Given a complete path, split into filedir and filename and return as vector.
      The filedir is normalized as uniform Java filepath.
      See also: java-filepath

    rewrite-cljs 0.4.4
    Comment-/Whitespace-preserving rewriting of EDN documents.
    rewrite-clj.paredit/split (cljs)SourceDoc + Usages
    Split current s-sexpression in two at given node `zloc`
    
      -  `[1 2 |3 4 5] => [1 2 3] [4 5]`

    re-com 2.1.0
    Reusable UI components for Reagent
    re-com.popover/split-keyword (cljs)SourceDoc + Usages
    Return the vector of the two keywords formed by splitting another keyword 'kw' on an internal delimiter (usually '-')
       (split-keyword  :above-left  "-") => [:above :left]

    clj-miscutil 0.5.0
    Miscellaneous utility functions/macros in Clojure
    clj-miscutil.core/split-filepathSourceDoc + Usages
    Given a complete path, split into filedir and filename and return as vector.
      The filedir is normalized as uniform Java filepath.
      See also: java-filepath

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.tree/split-samplesSourceDoc + Usages
    Returns a pair of lazy seqs of row indices of X that fall either to the left or right of the
      given split value and feature dimension.
    
      [left-samples right-samples]
      

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/build-new-urlSourceDoc + Usages
    Do the building necessary in replace-url-values here. url-parts is the split up url which values works as keys in param-map.

    I return the vector of the two keywords formed by splitting
       another keyword 'kw' on an internal delimiter (usually '-').
       (split-keyword  :above-left  "-")
       =>  [:above :left]

    omniconf.ssm 0.3.1
    Module for Omniconf to support Amazon SSM as a configuration source
    omniconf.ssm/get-parametersSourceDoc + Usages
    Fetches parameters from SSM recursively under the given `path`. Returns a map
      of keys to values, where keys are already split into vectors of keywords by
      the `separator`.

    liquid 0.9.2
    This project is an attempt to create a text editor for editing Clojure
    dk.salza.liq.tools.cshell/split-argumentsSourceDoc + Usages
    Splits arguments/vector into list of parameters
      and a map, if there are keywords.
      (split-arguments [1 2 3 :timeout 10]) -> [[1 2 3] {:timeout 10}]

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    re-com.popover/split-keyword (cljs)SourceDoc + Usages
    Return the vector of the two keywords formed by splitting another keyword 'kw' on an internal delimiter (usually '-')
       (split-keyword  :above-left  "-") => [:above :left]

    Goes through a string and splits it into a sequence of chunks
        based on opening and closing #( )# sections
    
        Ex. (del-split "test #(test)# test") => ("test" "#(test)#" "test")

    Goes through a string and splits it into a sequence of chunks
        based on opening and closing ##( )## sections
    
        Ex. (in-place-del-split "test ##(test)## test") => ("test" "##(test)##" "test")

    liq 0.4.3
    This project is an attempt to create a text editor for editing Clojure
    dk.salza.liq.cshell/split-argumentsSourceDoc + Usages
    Splits arguments/vector into list of parameters
      and a map, if there are keywords.
      (split-arguments [1 2 3 :timeout 10]) -> [[1 2 3] {:timeout 10}]

    numberto 0.0.4
    numberto - all you need to play with numbers
    numberto.solvers/binary-splitSourceDoc + Usages
    Build splits from numbers and binary code indicates gaps
    binary-split [1 2 3 4] [:gap :none :gap]) => [1 23 4]

    clash 1.4.1
    A clojure library that applies customizable structures to text files and quick
    clash.text_tools/text-structure-to-mapSourceDoc + Usages
    Split a structured text into map and return some/all entries. A specific
      pattern is required. If specific keys exist, then this functions creates
      a sub-map of the original map.

    ipbgp 0.3.0
    Library for interaction with the Shadowserver IP-BGP service
    ipbgp/split-peersSourceDoc + Usages
    The first element of the Shadowserver IP-BGP peers result is the query, the
      second is a space separeted list of peers. The argument res is a list of
      split IP-BGP elements.

    clojure-commons 0.1.0
    Marick's clojure utilities
    marick.clojure.core/separateSourceDoc + Usages
    Split coll into two sequences, one that matches pred and one that doesn't. Unlike the
      version in clojure.contrib.seq-utils, pred is only called once per item.

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/set-foldSourceDoc + Usages
    Set the current fold in the *dataset split* state.
    
      You must call [[divide-by-fold]] before calling this.
    
      See the namespace docs for more information.

    laser 1.1.2
    An HTML transformation library similar to Enlive/Tinsel.
    me.raynes.laser/split-keyword-argsSourceDoc + Usages
    Split an argument list into a map of keyword arguments and their values
       and a seq of the rest of the arguments. Assumes all of the keyword arguments
       come first in the list.

    fi 0.3.0
    Index and compare file trees.
    szew.fi.index/fetch-entrySourceDoc + Usages
    Get db connection, tag and path/rel_path, return entry with content
      split into vector of lines (if content captured, otherwise vector of single,
      empty string).
      

    spymemcat 0.1.0
    A Clojure client for memcached
    spymemcat.core/client-factorySourceDoc + Usages
    Split a string in the form of `host:port host2:port` into a List
      of InetSocketAddress instances suitable for instantiating a
      MemcachedClient. Note that colon-delimited IPv6 is also supported.

    aerial.bio.utils 2.0.0
    Various bioinformatic general utility tools
    aerial.bio.utils.files/sto->fnaSourceDoc + Usages
    Convert a sto file into a fasta file.  Split seq lines into names
       and seq data and interleave these.  Seq data has all gap characters
       removed.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-com.popover/split-keyword (cljs)SourceDoc + Usages
    Return the vector of the two keywords formed by splitting another keyword 'kw' on an internal delimiter (usually '-')
       (split-keyword  :above-left  "-") => [:above :left]

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.application/enqueue-mutationsSourceDoc + Usages
    Splits out the (remote) mutations and fallbacks in a transaction, creates an error handler that can
       trigger fallbacks, and enqueues the remote mutations on the network queue. If duplicate mutation names
       appear, then they will be separated into separate network requests.
    
       NOTE: If the mutation in the tx has duplicates, then the same fallback will be used for the
       resulting split tx. See `split-mutations` (which is used by this function to split dupes out of txes).

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.application/enqueue-mutationsSourceDoc + Usages
    Splits out the (remote) mutations and fallbacks in a transaction, creates an error handler that can
       trigger fallbacks, and enqueues the remote mutations on the network queue. If duplicate mutation names
       appear, then they will be separated into separate network requests.
    
       NOTE: If the mutation in the tx has duplicates, then the same fallback will be used for the
       resulting split tx. See `split-mutations` (which is used by this function to split dupes out of txes).

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/splitsSourceDoc + Usages
    Takes a measured object, an accumulator metric and a split value and
       returns a seq of IMeasured objects, representing the split intervals.
       Each interval will have a start/end point corresponding to the accumulator
       metric/value steps, and instants calculated by interpolation from 
       the surrounding points.
       All other metrics are also split between these instants and are included
       in the IMeasured object, if they have metric tracks. If they only have
       reduced values (such as max or avg), they are ignored.
       
       If the given metric is not an accumulator, or there's no track for it,
       this fn will return nil.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.application/enqueue-mutationsSourceDoc + Usages
    Splits out the (remote) mutations and fallbacks in a transaction, creates an error handler that can
       trigger fallbacks, and enqueues the remote mutations on the network queue. If duplicate mutation names
       appear, then they will be separated into separate network requests.
    
       NOTE: If the mutation in the tx has duplicates, then the same fallback will be used for the
       resulting split tx. See `split-mutations` (which is used by this function to split dupes out of txes).

    parallel-thrush 1.0.0
    Thrush, but with parallel sections
    parallel-thrush.core/||->>SourceDoc + Usages
    Acts as ->>, but runs sections in parallel.  Uses two keywords,
       :merge and :split, to delimit the sections, beginning with an
       implicit :split and ending with an implicit :merge.  Sections
       beginning with :split are expected to consume and produce
       sequences, while sections beginning with :merge are only expected
       to consume sequences.  The sections beginning with :split are run
       in parallel, and the output sequence is fed into the sections
       beginning with :merge in the order in which it would appear if it
       had not been run in parallel.
    
       Since the keywords :merge and :split are special, they can only be
       used as functions if enclosed in parentheses.
    
       (||->> x :merge ...) is equivalent to (->> x ...).
    
       To parallelize the data, it is partitioned into groups of size
       *parallel-thrush-partition-size*.  This variable can be altered
       using the binding special form, but if it is not altered, it is
       best not to make assumptions about the size of the partitions.
    
       For example, the following will probably loop infinitely:
    
       (||->> (range)
              (filter odd?)
              (take 100)
              :merge
              (reduce +))
    
       while this will produce the correct result:
    
       (||->> (range)
              (filter odd?)
              :merge
              (take 100)
              (reduce +))

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/partition-betweenSourceDoc + Usages
    Partition an input seq into multiple sequences, as with partition-by.
       Walks the collection two at a time, calling (split? [a b]) for each pair.
       Any time split? returns truthy, the partition containing a ends, and a new
       one containing b begins. Note that the split? predicate should not take two
       arguments, but instead a single argument, a pair.
    
       Like partition-by, a lazy sequence of partitions is returned, but the
       partitions themselves are eager.
    
       For example, to cause each nil to be folded into the next partition:
       (partition-between (fn [[a b]] (not (nil? a))) '[1 nil nil 2 nil 3])
       => ([1] [nil nil 2] [nil 3])

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.seq/partition-betweenSourceDoc + Usages
    Partition an input seq into multiple sequences, as with partition-by.
       Walks the collection two at a time, calling (split? [a b]) for each pair.
       Any time split? returns truthy, the partition containing a ends, and a new
       one containing b begins. Note that the split? predicate should not take two
       arguments, but instead a single argument, a pair.
    
       Like partition-by, a lazy sequence of paritions is returned, but the
       partitions themselves are eager.
    
       For example, to cause each nil to be folded into the next partition:
       (partition-between (fn [[a b]] (not (nil? a))) '[1 nil nil 2 nil 3])
       => ([1] [nil nil 2] [nil 3])

    aerial.bio.utils 2.0.0
    Various bioinformatic general utility tools
    aerial.bio.utils.files/split-join-ncbi-fasta-fileSourceDoc + Usages
    Split a fasta file IN-FILE into the individual sequences and
       unblock the sequence if blocked.  The resulting individual [nm sq]
       pairs are written to files named for the NC name in the gi line of
       in-file and in the DEFAULT-GENOME-FASTA-DIR location.
    
       The main use of this function is to take a refseq fasta
       db (composed of many multi seq fasta files) and split the db into a
       normed set of named sequence files for quick access to sequence per
       name in various other processing (see gen-name-seq for example).
    
       Canonical use case example:
    
       (fs/dodir "/data2/BioData/Fasta" ; RefSeqxx fasta files
                 #(fs/directory-files % "fna")
                 #(split-join-ncbi-fasta-file %))
      

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/alternatesSourceDoc + Usages
    Split coll into 'threads' subsequences (defaults to 2), feeding
      each alternately from the input sequence. Effectively the inverse of
      interleave:
    
      (alternates 3 (range 9))
      ;=> ((0 3 6) (1 4 7) (2 5 8))

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.seq/alternatesSourceDoc + Usages
    Split coll into 'threads' subsequences (defaults to 2), feeding
      each alternately from the input sequence. Effectively the inverse of
      interleave:
    
      (alternates 3 (range 9))
      ;=> ((0 3 6) (1 4 7) (2 5 8))

    hara.test 2.8.6
    patterns and utilities
    hara.test.form/splitSourceDoc + Usages
    creates a sequence of pairs from a loose sequence
       (split '[(def a 1)
                (+ a 3)
                => 5])
       => (contains-in [{:type :form,
                         :form '(def a 1)}
                        {:type :test-equal,
                         :input '(+ a 3),
                        :output 5}])

    lein-localrepo 0.5.4
    Leiningen local repository plugin
    leiningen.localrepo.internal/java-filepathSourceDoc + Usages
    Accept path (of a file) as argument and return a uniform file path for all
      operating systems.
      Example: "C:\path\to\file.txt" becomes "C:/path/to/file.txt"
      See also: split-filepath

    think.parallel 0.3.8
    Library for parallelization primitives
    think.parallel.core/launch-parallel-forSourceDoc + Usages
    Given a function that takes exactly 2 arguments, a start-index and a length,
    call this function exactly N times where N is ForkJoinPool/getCommonPoolParallelism.
    Indexes will be split as evenly as possible among the invocations.

    clj-miscutil 0.5.0
    Miscellaneous utility functions/macros in Clojure
    clj-miscutil.core/java-filepathSourceDoc + Usages
    Accept path (of a file) as argument and return a uniform file path for all
      operating systems.
      Example: "C:\path\to\file.txt" becomes "C:/path/to/file.txt"
      See also: split-filepath

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.tree/rand-splitterSourceDoc + Usages
    Returns a vector of [feature-indices split-value] where the feature-index for the
      chosen dimension has been removed from feature-indices.
    
      Note: assumes the feature-indices are already in random order.

    trapperkeeper-authorization 0.7.0
    Trapperkeeper authorization system
    puppetlabs.trapperkeeper.authorization.acl/split-domainSourceDoc + Usages
    Inputs: [domain :- schema/Str]
      Returns: [schema/Str]
    
      Given a domain string, split it on '.' and reverse it. For examples,
      'sylvia.plath.net' becomes ('net' 'plath' 'sylvia'). This is used for domain
      matching.

    semver 0.1.4
    Semantic version-ing library for Clojure
    org.ozias.cljlibs.semver.semver/identifier-precedenceSourceDoc + Usages
    Split the identifiers on '.', fill each vector with
      nil to the max of both, and the compare each identifier.
      The equal identifiers are filtered out and the first non-zero
      result is grabbed.
    
      If the result is nil the identifiers have equal precedence (0).

    random-forests-clj 0.2.0
    An implementation of Random Forests for classification in Clojure
    random-forests.core/build-and-evaluate-treeSourceDoc + Usages
    builds a tree from examples using features using m feature per split and bootstrap sample of size k
       returns tree with meta-data :eval which contains a map of {example [prediction] ...} on held out data

    open a new or existing bitcask
    
      takes the directory to write the cask files to, and a limit in bytes
      to split the files at
    
      when opening an already existing bitcask deletes all the dead files

    clawss 0.1.8
    clawss: clojure wrapper for web-service security
    clawss.core/split-mapSourceDoc + Usages
    Returns a pair of maps.
      First is the subset of map m that contains the keys.
      Second is the remainder of map m.
          (split-map #{:a :b} {:a 1 :b 2 :c 3}) => [{:a 1 :b 2} {:c 3}]
          

    functional-vaadin 0.2.2
    A functional interface to Vaadin
    functional-vaadin.core/horizontal-split-panelSourceDoc + Usages
    Usage: (horizontal-split-panel ctor_args? config_map? children?)
    
      Create a HorizontalSplitPanel component from constructor arguments or a configuration Map. Only zero or two children may
      be specified

    functional-vaadin 0.2.2
    A functional interface to Vaadin
    functional-vaadin.core/vertical-split-panelSourceDoc + Usages
    Usage: (vertical-split-panel ctor_args? config_map? children?)
    
      Create a VerticalSplitPanel component from constructor arguments or a configuration Map. Only zero or two children may
      be specified

    lein-lock 0.1.1
    A Leiningen plugin to check transitive dependencies against a dependencies.lock
    leiningen.lock/build-warSourceDoc + Usages
    builds war via pom, cf
      https://github.com/pedestal/docs/blob/master/documentation/service-war-deployment.md
      (TODO Probably could be via lein uberjar + web.xml)
      (TODO Split into a different project!)

    clj-thamil 0.2.0
    A project encompassing various Thamil language-specific computing ideas
    clj-thamil.format/str->lettersSourceDoc + Usages
    take a string and split it into its constitutent தமிழ் + non-complex letters (non-complex = all left-to-right, 1-to-1 codepoint-to-glyph encodings -- this includes all Western languages)

    cli-matic 0.1.11
    Compact [sub]command line parsing library, for Clojure
    cli-matic.core/get-options-summarySourceDoc + Usages
    To get the sumamry of options, we pass options to
      tools.cli parse-opts and an empty set of arguments.
      Parsing will fail but we get the :summary.
      We then split it into a collection of lines.

    pdf-stamper 0.4.1
    Combine template descriptions and template PDFs with data to produce PDFs.
    pdf-stamper.text.parsed/line-style->formatSourceDoc + Usages
    Adding font style information to a line means
      adding font style information to each part of that
      line. It is expected that a line is split into
      parts that each have the same styling.

    aerial.utils 1.2.0
    Utility 'tool belt' of functions for common tasks; trees; clustering; probability,
    aerial.utils.io/split-bindingsSourceDoc + Usages
    Split bindings into two vectors [bvec rwbinds], where bvec contains
      the binding pairs that are not top level reader or writer bindings,
      and rwbinds are all the reader and writer bindings. Either bvec or
      rwbinds may be empty.

    clj-shellwords 1.0.1
    Port of Ruby's Shellwords module
    clj-shellwords.core/shell-splitSourceDoc + Usages
    Splits a string into an array of tokens in the same way the UNIX Bourne
       shell does.
    
         (shell-split "these are 'three shell tokens'")
         ; ["these" "are" "three shell tokens"]
    
       Ported from Ruby's Shellwords#shellsplit()

    pithos 0.7.4
    cassandra-backed object storage
    io.pithos.operations/get-bucketSourceDoc + Usages
    List bucket content. It's worth noting that S3 has no actual concept of
       directories, instead, a delimiter can be supplied, in which case results will
       be split between contents and prefixes

    jeesql 0.4.7
    A Clojure library for using SQL
    jeesql.statement-parser/parameterSourceDoc + Usages
    Regular expression to split statement into three parts: before the first parameter,
    the parameter name and the rest of the statement. A parameter always starts with a single colon and
    may contain alphanumerics as well as '-', '_' and '?' characters.

    b-plus-tree 0.3.0
    A B+ Tree implemented in Clojure.
    b-plus-tree.core/split-internalSourceDoc + Usages
    Splits an :internal node. Do not attempt to split another type of node.
      Returns [[k p] header cache], where k is the key to push to the parent,
      and p is the pointer of the new (right) node.

    clj-util 1.3.7
    云驾工具函数库
    yunjia.util.string/splitSourceDoc + Usages
    对clojure.string/split的封装,可以接受nil输入,并且不会产生空串元素。

    asynp 0.0.3
    A core.async library for efficient subprocess management
    asynp.core/log-stringsSourceDoc + Usages
    Debugging aid: Given a channel delivering character buffers, log the contained strings using Timbre
    
      When given a character to split by, log only when a complete character-delimited buffer is received, or at end-of-stream.

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/idsSourceDoc + Usages
    Return all IDs based on the *dataset split* (see class docs).
    
      Keys
      ----
      * **:set-type** is either `:train`, `:test`, `:train-test` (all) and defaults
      to [[set-default-set-type]] or `:train` if not set

    pink 0.4.1
    A library for music research, composition, and performance.
    pink.io.sound-file/load-tableSourceDoc + Usages
    Load given file or filename as sampled audio.  Returns a map with meta-information as
      well as audio split into discrete channels. Converts to doubles from source format. 
      Currently only works with 16-bit PCM_SIGNED wave files.

    roap 0.1.2
    roap: rest over soap
    roap.utils/split-mapSourceDoc + Usages
    Returns a pair of maps.
      First is the subset of map m that contains the keys.
      Second is the remainder of map m.
          (split-map #{:a :b} {:a 1 :b 2 :c 3}) => [{:a 1 :b 2} {:c 3}]
          

    combit 0.3.0
    Intuitive and concise processing of fixed-size Data Containers.
    combit.stream/split-inputsSourceDoc + Usages
    Create lazy seq of inputs consisting of data with the given element count.
       Example:
    
          (split-inputs [[1 2 3 4] [1 2]] [2 1])
          ;=> ( ([1 2] [1]) ([3 4] [2]) )
       
       No padding is performed.

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicateSourceDoc + Usages
    Splits a collection to items where the separator is a repetition of at least n elements that satisfy `pred`.
    
      Inspired by: [this question](http://stackoverflow.com/a/23555616/813665).
    
    ~~~klipse
      (split-by-predicate (shuffle (range 30)) even? 2)
    ~~~
      

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicateSourceDoc + Usages
    Splits a collection to items where the separator is a repetition of at least n elements that satisfy `pred`.
    
      Inspired by: [this question](http://stackoverflow.com/a/23555616/813665).
    
    ~~~klipse
      (split-by-predicate (shuffle (range 30)) even? 2)
    ~~~
      

    boot-boot 0.6.0
    Batteries-included Clojure development and release workflows using Boot.
    clj-boot.string/delimited-wordsSourceDoc + Usages
    Split a string into words, respecting single or double quoted substrings.
      Nested quotes are not supported.  Unbalanced quotes will return undefined
      results.
    (=> [string?] :clj-boot.string/word-vector)

    seesaw 1.5.0
    A Swing wrapper/DSL for Clojure. You want seesaw.core, FYI. See http://seesaw-clj.org
    seesaw.core/splitterSourceDoc + Usages
      Create a new JSplitPane. This is a lower-level function. Usually you want
      (seesaw.core/top-bottom-split) or (seesaw.core/left-right-split). But here's
      the additional options any three of these functions can take:
    
        :divider-location The initial divider location. See (seesaw.core/divider-location!).
    
      Notes:
    
      See:
        http://download.oracle.com/javase/6/docs/api/javax/swing/JSplitPane.html
      

    clj-cctray 1.0.0
    Clojure parser for cctray.xml
    clj-cctray.util/sentenceizeSourceDoc + Usages
    Sentenceizes the given string which means camel, snake, kebab and dot cased strings are turned into normal sentences
      with spaces. This function will not split the following:
    
      1. Multiple uppercased letters in a row
      2. Digits separated by dots
    
      This is in an attempt to keep acronyms/initialisms and version numbers from getting split.
    
      For example:
    
          "CamelCased_SNAKE-kebab.dot_JSON-1.2.3" => "Camel Cased SNAKE kebab dot JSON 1.2.3"

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/partition-betweenSourceDoc + Usages
    Splits a collection between two items according to predicate `pred` - which means split the sequence on breaking point.
    
      See: [here](http://stackoverflow.com/questions/23207490/partition-a-seq-by-a-windowing-predicate-in-clojure)
    
      For instance, split each time the series stop being ascending:
    
    ~~~klipse
    (partition-between > [1 2 4 9 8 7 6 5 1 2 4 5 11])
    ~~~
    

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/partition-betweenSourceDoc + Usages
    Splits a collection between two items according to predicate `pred` - which means split the sequence on breaking point.
    
      See: [here](http://stackoverflow.com/questions/23207490/partition-a-seq-by-a-windowing-predicate-in-clojure)
    
      For instance, split each time the series stop being ascending:
    
    ~~~klipse
    (partition-between > [1 2 4 9 8 7 6 5 1 2 4 5 11])
    ~~~
    

    Usage: 
    
        (partition-between pred coll)
    
        splits a collection between two items according to the pred.
        which means split the sequence on breaking point.
    
      See: [here](http://stackoverflow.com/questions/23207490/partition-a-seq-by-a-windowing-predicate-in-clojure)
    
      For instance:
        split when ascending serie breaks.
    
        (partition-between (fn [a b] (> a b)) [1 2 4 9 4 6 8 2]) => [[1 2 4 9] [4 6 8] [2]]

    Usage: 
    
        (partition-between pred coll)
    
        splits a collection between two items according to the pred.
        which means split the sequence on breaking point.
    
      See: [here](http://stackoverflow.com/questions/23207490/partition-a-seq-by-a-windowing-predicate-in-clojure)
    
      For instance:
        split when ascending serie breaks.
    
        (partition-between (fn [a b] (> a b)) [1 2 4 9 4 6 8 2]) => [[1 2 4 9] [4 6 8] [2]]

    clj-usps 1.0.0
    Clojure interface to the USPS Web Tools API
    usps.models.core/record->xmlSourceDoc + Usages
    Note that this is split up into phases due to different data being
      passed through each major phase.
    
      The code was changed from a staight-forward thrushing to this once we
      realized that the USPS API requires XML elements to be in a fixed order (!?).
      Phase 2 was introduced for this, but since the data that is thrushes isn't
      the same as that passed through the others, it had to be split out.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce/input-format!SourceDoc + Usages
    Allocate and return a new input format class for `conf` as invoking `svar` to
    generate input-splits and invoking `rvar` to generate record-readers.
    
    During local job initialization, the function referenced by `svar` will be
    invoked with the job context followed by any provided `sargs` (which must be
    EDN-serializable); it should return a sequence of input split data.  Any values
    in the returned sequence which are not `InputSplit`s will be wrapped in
    `EdnInputSplit`s and must be EDN-serializable; in such a case, the `::mr/length`
    and `::mr/locations` keys of such data may provide the split byte-size and node
    locations respectively.
    
    Prior to use, the function reference by `rvar` will be transformed by the
    function specified as the value of the `readerv`'s `::mr/adapter` metadata,
    defaulting to `parkour.mapreduce/recseqfn`.  During remote task-setup, the
    transformed function will be invoked with the task input split and task context
    followed by any provided `rargs`; it should return a `RecordReader` generating
    the task input data.
    
    See also: `recseqfn`.

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.fnk.schema/split-schema-keys (cljs)SourceDoc + Usages
    Inputs: [s :- {s/Keyword s/Bool}]
      Returns: [(s/one [s/Keyword] (quote required)) (s/one [s/Keyword] (quote optional))]
    
      Given output of explicit-schema-key-map, split into seq [req opt].

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.fnk.schema/split-schema-keysSourceDoc + Usages
    Inputs: [s :- {s/Keyword s/Bool}]
      Returns: [(s/one [s/Keyword] (quote required)) (s/one [s/Keyword] (quote optional))]
    
      Given output of explicit-schema-key-map, split into seq [req opt].

    lamina 0.5.6
    event-driven data structures for clojure
    lamina.core/splitSourceDoc + Usages
    Returns a channel which will forward each message to all downstream-channels.
       This can be used with sink->>, siphon->>, and join->> to define complex
       message flows:
    
       (join->> (map* inc)
         (split
           (sink->> (filter* even?) log-even)
           (sink->> (filter* odd?) log-odd)))

    buddy-core 1.5.0
    Cryptographic Api for Clojure.
    buddy.core.crypto/split-by-blocksizeSourceDoc + Usages
    Split a byte array in blocksize blocks.
    
      Given a arbitrary size bytearray and block size in bytes,
      returns a lazy sequence of bytearray blocks of blocksize
      size. If last block does not have enought data for fill
      all block, it is padded using zerobyte padding.

    rethinkdb 0.10.1
    RethinkDB client
    rethinkdb.query/splitSourceDoc + Usages
    Splits a string into substrings. Splits on whitespace when called with no
      arguments. When called with a separator, splits on that separator. When
      called with a separator and a maximum number of splits, splits on that
      separator at most ```max-splits``` times. (Can be called with ```nil``` as the separator
      if you want to split on whitespace while still specifying ```max-splits```.)

    pedestal.route 0.5.3
    Pedestal route definition and router construction
    io.pedestal.http.route.prefix-tree/splitSourceDoc + Usages
    Given a node, a path-spec, a payload object to insert into the tree
      and the lcs, split the node and return a new parent node with the
      old contents of node and the new item as children.
    
      lcs is the index of the longest common string in path-spec and the
      segment of node.

    seesaw 1.5.0
    A Swing wrapper/DSL for Clojure. You want seesaw.core, FYI. See http://seesaw-clj.org
    seesaw.core/top-bottom-splitSourceDoc + Usages
    Create a top/bottom (vertical) split pane with the given widgets. See
      (seesaw.core/splitter) for additional options. Options are given after
      the two widgets.
    
      Notes:
    
      See:
        (seesaw.core/splitter)
        http://download.oracle.com/javase/6/docs/api/javax/swing/JSplitPane.html
      

    hara.ova 2.1.12
    code patterns and utilities
    hara.ova/splitSourceDoc + Usages
    creates an exact copy of the ova, including its watches
      (let [o (ova (range 10))
            sp (dosync (split o #{'(< 3) '(> 6)}))]
        (persistent! (sp true))  => [0 1 2 7 8 9]
        (persistent! (sp false)) => [3 4 5 6])

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.compute.math/batched-data-to-per-input-dataSourceDoc + Usages
    Given a sequence of DeviceArrays return a sequence of arrays with the device
    arrays split into one entry per batch.  So for example if I have a batch size of 5
    and I pass in [input output] then I get batch [[input-1 input-2 ...][output-1 output-2 ...]]

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.parser/inline-shell-cmd-lineSourceDoc + Usages
    input: shell command on its own line, e.g.
      $(echo '%include dude.d')
      The output of the shell command will be placed inline the workflow file.
      This can be recursive, i.e. shell commands can print more shell commands.
    
      Split into two parts for much the same reason as inclusion-directive-line is.

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.parser/inline-shell-cmd-lineSourceDoc + Usages
    input: shell command on its own line, e.g.
      $(echo '%include dude.d')
      The output of the shell command will be placed inline the workflow file.
      This can be recursive, i.e. shell commands can print more shell commands.
    
      Split into two parts for much the same reason as inclusion-directive-line is.

    clj-figlet 0.1.1
    Library to generate text banners in an 'ASCII Art' style using FIGlet fonts.
    clj-figlet.core/renderSourceDoc + Usages
    Renders a string of text using the given FIGlet font. The rendered output is returned
       as a sequence of lines. The text given is split up on each newline character found and
       each line is rendered as a new line in the output. So the number of lines in the final
       rendered output will be equal to [number of lines in 's'] * [height of flf font]

    compute 0.5.0
    Compute abstraction and cpu implementation. Meant to abstract things like openCL
    think.compute.math/batched-data-to-per-input-dataSourceDoc + Usages
    Given a sequence of DeviceArrays return a sequence of arrays with the device
    arrays split into one entry per batch.  So for example if I have a batch size of 5
    and I pass in [input output] then I get batch [[input-1 input-2 ...][output-1 output-2 ...]]

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.transport.graphite/decode-graphite-lineSourceDoc + Usages
    Decode a line coming from graphite.
    
      Graphite uses a simple scheme where each metric is given as a CRLF delimited
      line, whitespace split (space, tab) with three items:
    
      * The metric name
      * The metric value (optionally NaN)
      * The timestamp
    
      Decode-graphite-line will yield a simple event with just a service, metric,
      and timestamp.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.transport.graphite/decode-graphite-lineSourceDoc + Usages
    Decode a line coming from graphite.
    
      Graphite uses a simple scheme where each metric is given as a CRLF delimited
      line, whitespace split (space, tab) with three items:
    
      * The metric name
      * The metric value (optionally NaN)
      * The timestamp
    
      Decode-graphite-line will yield a simple event with just a service, metric,
      and timestamp.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.entity.datomic/split-schemaSourceDoc + Usages
    Takes an entity schema and splits it into multiple
       entity schemas based on attribute prefixes. An entity
       with a spec like
    
           (s/keys :req [:foo/bar :baz/ruux])
    
       would yield an entity schema like
    
           {:foo/bar [...]
            :baz/ruux [...]}
    
       and would be split into
    
           {:foo {:foo/bar [...]}
            :baz {:bar/ruux [...]}}

    hara.concurrent.ova 2.8.6
    patterns and utilities
    hara.concurrent.ova/splitSourceDoc + Usages
    splits an ova into two based on a predicate
       
       (def o (ova (range 10)))
       (def sp (dosync (split o #{'(< 3) '(> 6)})))
     
       (persistent! (sp true))  => [0 1 2 7 8 9]
       (persistent! (sp false)) => [3 4 5 6]

    lucid.core.debug 1.4.6
    tools for code clarity
    lucid.core.debug/dbg->>SourceDoc + Usages
    prints each stage of the `->>` macro
       
       (->  (dbg->> (range 5)
                    (map inc)
                    (take 2))
           (with-out-str)
           (string/split-lines))
       => ["" ""
           "(0 1 2 3 4)"
           "->> (map inc) :: (1 2 3 4 5)"
          "->> (take 2) :: (1 2)"]

    lucid.core.debug 1.4.6
    tools for code clarity
    lucid.core.debug/dbg->SourceDoc + Usages
    prints each stage of the `->` macro
       (-> (dbg-> {:a 1}
                            (assoc :b 2)
                            (merge {:c 3}))
           (with-out-str)
           (string/split-lines))
       => ["" ""
           "{:a 1}"
          "-> (assoc :b 2) :: {:a 1, :b 2}"
           "-> (merge {:c 3}) :: {:a 1, :b 2, :c 3}"]

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.application/split-mutationsSourceDoc + Usages
    Split a tx that contains mutations. Returns a vector that contains at least one tx (the original).
    
       Examples:
       [(f) (g)] => [[(f) (g)]]
       [(f) (g) (f) (k)] => [[(f) (g)] [(f) (k)]]
       [(f) (g) (f) (k) (g)] => [[(f) (g)] [(f) (k) (g)]]
       

    spirit.mail.common 0.8.1
    data. simplified
    spirit.mail.common/to-stringSourceDoc + Usages
    converts a Message object into a string
     
       (-> (message/message {:from "a@a.com"
                             :to ["b@b.com"]
                             :body "HELLO WORLD"})
           (to-string ["Date" "Message-ID" "Content-Transfer-Encoding" "Content-Type"])
           (string/split-lines))
       => ["From: a@a.com"
          "To: b@b.com"
           "MIME-Version: 1.0"
           ""
           "HELLO WORLD"]

    geni-gedcom 0.0.9
    A GEDCOM to Geni importer.
    geni.gedcom.common/date-to-mapSourceDoc + Usages
    For simple date structures where each segment is simply
      separated by a single delimiter (like - or /), split on
      that delimiter and then create a map of :month, :day,
      and :year. Sometimes these are in reverse. In thos cases,
      you can pass a third argument (truthy) to reverse the
      ordering.

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.impl/indent-lines-withSourceDoc + Usages
    Inputs: [indent-str :- s/Str txt :- s/Str]
      Returns: s/Str
    
      Splits out each line of txt using clojure.string/split-lines, then
      indents each line by prepending it with the supplied string. Joins lines together into
      a single string result, with each line terminated by a single 
    ewline.

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.string/indent-lines-withSourceDoc + Usages
    Inputs: [indent-str :- s/Str txt :- s/Str]
      Returns: s/Str
    
      Splits out each line of txt using clojure.string/split-lines, then
      indents each line by prepending it with the supplied string. Joins lines together into
      a single string result, with each line terminated by a single 
    ewline.

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.string/indent-linesSourceDoc + Usages
    Inputs: [n :- s/Int txt :- s/Str]
      Returns: s/Str
    
      Splits out each line of txt using clojure.string/split-lines, then
      indents each line by prepending N spaces. Joins lines together into
      a single string result, with each line terminated by a single 
    ewline.

    Inputs: [s :- {s/Keyword s/Bool}]
      Returns: [(s/one [s/Keyword] (quote required)) (s/one [s/Keyword] (quote optional))]
    
      Given output of explicit-schema-key-map, split into seq [req opt].

    spirit.net.mail 0.9.0
    systems. simplified
    spirit.net.mail.common/to-stringSourceDoc + Usages
    converts a Message object into a string
     
       (-> (message/message {:from "a@a.com"
                             :to ["b@b.com"]
                             :body "HELLO WORLD"})
           (to-string ["Date" "Message-ID" "Content-Transfer-Encoding" "Content-Type"])
           (string/split-lines))
       => ["From: a@a.com"
          "To: b@b.com"
           "MIME-Version: 1.0"
           ""
           "HELLO WORLD"]

    clj-thamil 0.2.0
    A project encompassing various Thamil language-specific computing ideas
    clj-thamil.format/str->elemsSourceDoc + Usages
    take a string and split it into chunks based on the input trie.  for every maximally long sequence in the trie that is detected in the input string, the terminus-attached value is added to the output sequence if it exists (ex: useful for transliteration / format conversion), or else the string chunk itself is added.

    batteries 0.2.40
    a little library with helper and convenience functions
    de.sushi3003.batteries/separateSourceDoc + Usages
    Split `coll` into a sequence of two sequences: one whose elements all
       satisfy `pred` and one whose elements all do not satisfy `pred`. Returns a
       stateful transducer when no collection is provided.
       
       ```
       (separate odd? [1 2 3 4]) => [[1 3] [2 4]]
       ```

    lucid.flight.debug 1.1.0
    tools for clarity
    lucid.flight.debug/dbg->>SourceDoc + Usages
    prints each stage of the `->>` macro
       
       (->  (dbg->> (range 5)
                    (map inc)
                    (take 2))
           (with-out-str)
           (string/split-lines))
       => ["" ""
           "(0 1 2 3 4)"
           "->> (map inc) :: (1 2 3 4 5)"
          "->> (take 2) :: (1 2)"]

    lucid.flight.debug 1.1.0
    tools for clarity
    lucid.flight.debug/dbg->SourceDoc + Usages
    prints each stage of the `->` macro
       (-> (dbg-> {:a 1}
                            (assoc :b 2)
                            (merge {:c 3}))
           (with-out-str)
           (string/split-lines))
       => ["" ""
           "{:a 1}"
          "-> (assoc :b 2) :: {:a 1, :b 2}"
           "-> (merge {:c 3}) :: {:a 1, :b 2, :c 3}"]

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/make-splitSourceDoc + Usages
    Helper fn to produce a Split for some IMeasured. It takes a measured obj
       and a metric track. It walks over all of the other metric tracks and splits
       them at the same start/end instants as the given metric track. All of these
       are then used for the reified IMeasured obj that this fn returns

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/sentiment-mapsSourceDoc + Usages
    Return a sequence of sentiment-maps, one for each sentence in `text`.
                 Each sentiment map contains a `:sentiment` key, and a `:text` key.
    
                 `sentiment` is [0, 4], from very negative to very positive.
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    thinkdb 0.9.39
    RethinkDB client
    rethinkdb.query/splitSourceDoc + Usages
    Splits a string into substrings. Splits on whitespace when called with no
      arguments. When called with a separator, splits on that separator. When
      called with a separator and a maximum number of splits, splits on that
      separator at most ```max-splits``` times. (Can be called with ```nil``` as the separator
      if you want to split on whitespace while still specifying ```max-splits```.)

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.application/split-mutationsSourceDoc + Usages
    Split a tx that contains mutations. Returns a vector that contains at least one tx (the original).
    
       Examples:
       [(f) (g)] => [[(f) (g)]]
       [(f) (g) (f) (k)] => [[(f) (g)] [(f) (k)]]
       [(f) (g) (f) (k) (g)] => [[(f) (g)] [(f) (k) (g)]]
       

    touchstone 0.5.0
    Simple, Redis-backed split-testing for Clojure.
    taoensso.touchstone.ring/wrap-random-test-subject-idSourceDoc + Usages
    Wraps Ring handler to randomly generate, sessionize, and bind a test-subject
      id for request. Request's User-Agent header will be checked, and bots excluded
      from split-testing by having their id set to nil.
    
      Use custom middleware for more sophisticated bot testing, exclusion of staff
      requests, etc.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.utils.i18n-io/list->nested-maps-listSourceDoc + Usages
    Convert a list with the first member a '/' encoded namespace and the rest
      values to a list of maps, one for each value, nested based on the namespace
      split and converted to a keyword.
    
      E.g. ['a/b/c' 1 2] => [{:a {:b {:c 1}}} {:a {:b {:c 2}}}]

    sql-tie 0.1.4
    Sql query utility
    tie.core/get-moduleSourceDoc + Usages
    -> Get tie module. If not found add error to tie module.
          Split query string and convert it to vector.
          Update query module sql key.
    
      @param {map} db "Tie modules as map"
      @param {keyword} name "Name of the tie module."
      @return "Tie module as map "

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/write-datasetSourceDoc + Usages
    Write the data set to a spreadsheet.  If the file name ends with a `.csv` a
      CSV file is written, otherwise an Excel file is written.
    
      Keys
      ----
      * **:output-file** where to write the file and defaults to
      [[res/resource-path]] `:analysis-report`
      * **:single?** if `true` then create a single sheet, otherwise the training
      and testing *buckets* are split between sheets

    comporoute 0.2.0
    Composable request handling.
    comporoute.util/compose-pathSourceDoc + Usages
    Multi-purpose path-builder:
    
      Split sub-paths into more sub-paths if they contain slashes, replace
      batched slashes with a single slash, concat all sub-paths with
      slashes between them.
    
      If no sub-paths could be composed, return the empty-string.
    
      Sub-paths must be strings and may not be nil.

    specialist-server 0.4.0
    Spec-driven Clojure GraphQL server
    specialist-server.parser/graphql-two-stepSourceDoc + Usages
    ANTLR graphql parser croaks if reserved words are used in selectionSet or variableDefinition:
      'query', 'mutation', 'subscription', 'fragment', 'on'
    
      As a workaround we can split parsing into two steps. The downside is that this is slower.
      So we try to parse queries in single pass first and if it fails we fall back to this.

    clj-symphony 0.8.0
    A Clojure wrapper around the symphony-java-client library.
    clj-symphony.message/tokensSourceDoc + Usages
    Returns the tokens (words) in the given MessageML message, in all lower case.  Splits on whitespace and punctuation
      (via the Java regex pattern `[\p{Punct}\s]+`).  Note that message content that contains whitespace within a single
      tag will also be split - this is especially noticable for @mentions containing a person's first and last names.

    geo 1.2.1
    Geospatial operations over points, lines, polys, geohashes, etc.o
    geo.poly/bisect-regionSourceDoc + Usages
    Takes a region and returns two new regions, each representing one side of the axis-aligned
      bisection of the original. Any edge crossing the bisecting line is split, and any gaps created by
      bisection are filled by using segments from the bisecting line.

    bootstrap-cljs 0.28.1-0
    ClojureScript wrapper around React Bootstrap
    plumbing.fnk.schema/split-schema-keys (cljs)SourceDoc + Usages
    Inputs: [s :- {s/Keyword s/Bool}]
      Returns: [(s/one [s/Keyword] (quote required)) (s/one [s/Keyword] (quote optional))]
    
      Given output of explicit-schema-key-map, split into seq [req opt].

    sparse 0.1.3
    Generate sparse bit array representations of fundamental data types.
    sparse.utils/long->bit-rangesSourceDoc + Usages
    Look at how many bits are required to represent the value 'l' in binary
      and returns a sequence of numbers specifying the size of 'n' bit blocks
      into which the number's bits can be split. Because the number can't always
      be split into bit blocks of the same size, any additional bits are added to
      the initial blocks.
    
      For example, the number 127 can be represented with 7 bits. If there are
      two blocks, the first with have 4 bits and the second with have 3.
    
      (long->bitranges 127, 2) => (4, 3)
    
      If the number of bits required to represent the number is lower than 'n' the
      number of blocks requested, the ranges returned will be all of one bit size
      and there will be 'n' of them.

    cd-client 0.3.6
    A client for the clojuredocs API
    cd-client.core/searchSourceDoc + Usages
    Search for symbols whose names contain a specified string, or in
      local mode, symbols whose names match a specified regex pattern.
      With a single argument, all symbols in known namespaces are
      searched. With two arguments, only the namespace whose name is
      specified by the string ns is searched.
    
      Examples:
    
      (search "split")      ; symbol name contains 'split'
      (search ">")          ; contains '>'
      (search "clojure.core" "with") ; contains 'with' and is in
                                         ; namespace clojure.core
    
      In local mode, you can do regex searches. Regex searches are not
      supported by the clojuredocs web site search API at this time.
    
      (search "clojure.core" "^with") ; begins with 'with' and is in
                                          ; namespace clojure.core
      (search #"sp[al]")    ; symbol name contains 'sp' followed by 'a' or 'l'
      (search #"let$")      ; ends with 'let'
      (search #"(?i)array") ; symbol name contains 'array', matched
                              ; case-insensitively

    essbase 0.1.1
    Consume various files produced by Essbase.
    szew.essbase.logs/maxl-spoolSourceDoc + Usages
    Process MaxL spool files, packs are data from prompt to prompt.
    
      Gives:
    
      {:head [String], :data [{Keyword String}], :tail [String]}
      ;; or
      {:head [String], :data [], :tail []}
    
      MaxL spool setup:
    
      MAXL> set column_width 256;
    
      MAXL> set timestamp on;
    
      MAXL> spool on to '/your/file/location.log';
    
      And then process output:
    
      * Split by maxl-prompt? into blocks.
      * If no lines in block are multiple of column-width:
        - Head: just trimmed lines from the block
        - Data: empty vector
        - Tail: empty vector
      * If any lines in block are multiples of column-width:
        - Head: prompt (lines before wide lines)
        - Data: data (fixed-width tabular data, split, trimmed, recordified)
        - Tail: additional output at the end: INFO, WARNING, timestamp etc.
    
      Each returned map is having some meta attached, might want to take a peek.
      

    merkle-db-core 0.1.0
    Hybrid data store built on merkle trees.
    merkle-db.record/split-dataSourceDoc + Usages
    Split new record values into collections grouped by family. Each configured
      family and `:base` will have an entry in the resulting map, containing a
      vector of record keys to new values. The values may be `nil` if the record
      had no data for that family, an empty map if the family is `:base` and all
      the record's data is in other families, or a map of field data belonging to
      that family.
    
      ```
      {:base [[#merkle-db/key "00" {:a 123}] ...]
       :bc [[#merkle-db/key "00" {:b true, :c "cat"}] ...]
       ...}
      ```

    seesaw 1.5.0
    A Swing wrapper/DSL for Clojure. You want seesaw.core, FYI. See http://seesaw-clj.org
    seesaw.mig/mig-panelSourceDoc + Usages
    Construct a panel with a MigLayout. Takes one special property:
    
          :constraints ["layout constraints" "column constraints" "row constraints"]
    
      These correspond to the three constructor arguments to MigLayout.
      A vector of 0, 1, 2, or 3 constraints can be given.
    
      The format of the :items property is a vector of [widget, constraint] pairs.
      For example:
    
        :items [[ "Propeller"        "split, span, gaptop 10"]]
    
      See:
        http://www.miglayout.com
        (seesaw.core/default-options)
      

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.clj-frontend-utils/var-split-reSourceDoc + Usages
    Regular expression to split a string at variables while also
      returning the strings before and after each variable.
    
      Given this string, "XXX$[var]YYY$[var2]"
    
      The first match will be a re-group with four elements as follows
      ["XXX$[var]YYY" "XXX" "var" "YYY"]
    
      The first element is the entire match, the second element is the
      string before the variable, the third element is the variable name
      and the forth elment is the string after the variable up to the next
      variable.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/split*SourceDoc + Usages
    Given a list of function and stream pairs, passes the current event onto the
      stream associated with the first passing condition.
    
       Conditions are functions as for where*.  An odd number of forms will make
      the last form the default stream. For example:
    
      ```clojure
       (split*
         (fn [e] (< 0.9  (:metric e))) (with :state "critical" index)
         (fn [e] (< 0.75 (:metric e))) (with :state "warning" index)
         (with :state "ok" index))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/split*SourceDoc + Usages
    Given a list of function and stream pairs, passes the current event onto the
      stream associated with the first passing condition.
    
       Conditions are functions as for where*.  An odd number of forms will make
      the last form the default stream. For example:
    
      ```clojure
       (split*
         (fn [e] (< 0.9  (:metric e))) (with :state "critical" index)
         (fn [e] (< 0.75 (:metric e))) (with :state "warning" index)
         (with :state "ok" index))
      ```

    etaoin 0.2.8
    Pure Clojure Webdriver protocol implementation.
    etaoin.api/get-element-attrSourceDoc + Usages
    Returns an HTTP attribute of an element (class, id, href, etc).
    
      Arguments:
    
      - `driver`: a driver instance,
    
      - `q`: a query term to find an element,
    
      - `name`: either a string or a keyword with a name of an attribute.
    
      Returns: a string with the attribute value, `nil` if no such
      attribute for that element.
    
      Note: it does not split CSS classes! A single string with spaces is
      returned.
    
      Example:
    
      (def driver (firefox))
      (get-element-attr driver {:tag :a} :class)
      >> "link link__external link__button" ;; see note above
    

    clj-thamil 0.2.0
    A project encompassing various Thamil language-specific computing ideas
    clj-thamil.format/wordy-seqSourceDoc + Usages
    take a string and produce a seq of the Unicode-aware version of the \w+ regex pattern - basically, split input string into all chunks of non-whitepsace.  Originally, I called this fn word-seq, but that is not true for all languages and/or throughout time where there was no spearation between words (ex: Thai, Chinese, Japanese, Latin manuscripts, ancient Thamil stone inscriptions, etc.)

    aerial.utils 1.2.0
    Utility 'tool belt' of functions for common tasks; trees; clustering; probability,
    aerial.utils.math.clustering/loyd-stepSourceDoc + Usages
    Primary step in kmeans algorithm.  Recluster data to the 'new'
       centers incenters.  Take new clusters and compute and return newer
       centers for all new clusters.  That's the basic Loyd step, but here
       there is an extra wrinkle:
    
       If (count new-clusters) is not equal (count incenters), some input
       clusters have coalesced and need to be resplit (see
       split-worst-cluster).  The result is then 'restepped' until the
       count of new clusters is count of incenters.
      

    lucid.mind 1.4.6
    tools for code clarity
    lucid.mind/.>varSourceDoc + Usages
    extracts a class method into a namespace.
     
       (.>var hash-without [clojure.lang.IPersistentMap without])
     
       (->> (eval '(clojure.repl/doc hash-without))
            with-out-str
            string/split-lines
            (drop 2))
       =>  ["[[clojure.lang.IPersistentMap java.lang.Object]]"
            "  "
            "member: clojure.lang.IPersistentMap/without"
            "type: clojure.lang.IPersistentMap"
            "modifiers: instance, method, public, abstract"]
     
       (eval '(hash-without {:a 1 :b 2} :a))
       => {:b 2}

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/pos-ner-mapsSourceDoc + Usages
    Return a sequence of pos-ner-maps, one for each sentence in `text`.
                 Each sentiment map contains a ':tokens` key, and a `:text` key.
    
                 `tokens` is a sequence of tokens with POS and NER markup from each
                          bit of `text`. A token looks like:
    
                          {:pos "NNP", :ner "ORGANIZATION", :token "Google"}
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/sentiment-ner-mapsSourceDoc + Usages
    Return a sequence of sentiment-ner-maps, one for each sentence in `text`.
                 Each sentiment map contains a `:sentiment` key, a ':tokens` key,
                 and a `:text` key.
    
                 `sentiment` is [0, 4], from very negative to very positive.
    
                 `tokens` is a sequence of tokens with POS and NER markup from each
                          bit of `text`. A token looks like:
    
                          {:pos "NNP", :ner "ORGANIZATION", :token "Google"}
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    chromex 0.6.1
    A ClojureScript wrapper for writing Chrome Extensions and Apps.
    chromex.app.runtime/tap-on-startup-eventsSourceDoc + Usages
    Fired when a profile that has this extension installed first starts up. This event is not fired when an incognito profile
       is started, even if this extension is operating in 'split' incognito mode.
    
       Events will be put on the |channel| with signature [::on-startup []].
    
       Note: |args| will be passed as additional parameters into Chrome event's .addListener call.
    
       https://developer.chrome.com/apps/runtime#event-onStartup.

    clj-cn-mmseg 0.1.5
    clj-cn-mmseg是一个用clojure实现的mmseg中文分词工具包。
    clj-cn-mmseg.trie/add-to-trieSourceDoc + Usages
    Add element to trie. The element can take optional argument which 
    specify the nature of the words. Feature should be an string indicate
    the property of the word.
    Ex:{\h {\e {\l {\l {\c {:nature {:n true}}, \o {:nature {:n true}}}}}}}
    The nature hash of the nodes is the nature of the word from root to the 
    current node. 
    The feature is an hash indicate the nature of the word. If it is ommited,
    it will have a default value of {:split-only true}, which indicate the word
    is an word for segment only.
    

    touchstone 0.5.0
    Simple, Redis-backed split-testing for Clojure.
    taoensso.touchstone/with-test-subjectSourceDoc + Usages
    Executes body (e.g. handling of a Ring web request) within the context of a
      thread-local binding for test-subject id. Ids allow us to present a consistent
      user experience to each test subject for some reasonable duration.
    
      Suitable ids include: user account id, session key, etc. When nil/unspecified,
      subject will not participate in split-testing (useful for staff/bot web
      requests, etc.).

    twttr 3.2.0
    Twitter API client supporting REST, streaming, and OAuth
    twttr.middleware/parse-bodySourceDoc + Usages
    Parse `body` (a java.io.InputStream from an HTTP response) as JSON or a
      string, depending on the Content-Type header.
    
      If the Transfer-Encoding header is 'chunked', `body` is split on newlines,
      empty lines are dropped, and the rest are parsed as individual JSON documents.
    
      `json-options` is passed directly on to json/read(-str), after the default of
      {:key-fn keyword}, and in the non-streaming case, {:eof-error? false}.

    lucid.flight.reflection 1.1.0
    tools for clarity
    lucid.flight.reflection/.>varSourceDoc + Usages
    extracts a class method into a namespace.
     
       (.>var hash-without [clojure.lang.IPersistentMap without])
     
       (->> (eval '(clojure.repl/doc hash-without))
            with-out-str
            string/split-lines
            (drop 2))
       =>  ["[[clojure.lang.IPersistentMap java.lang.Object]]"
            "  "
            "member: clojure.lang.IPersistentMap/without"
            "type: clojure.lang.IPersistentMap"
            "modifiers: instance, method, public, abstract"]
     
       (eval '(hash-without {:a 1 :b 2} :a))
       => {:b 2}

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/instancesSourceDoc + Usages
    Return all instance data based on the *dataset split* (see class docs).
    
      See [[instance-by-id]] for the data in each map sequence returned.
    
      Keys
      ----
      * **:set-type** is either `:train`, `:test`, `:train-test` (all) and defaults
      to [[set-default-set-type]] or `:train` if not set
      * **:include-ids?** if non-`nil` return keys in the map as well

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/set-population-useSourceDoc + Usages
    Set how much of the data from the DB to use.  This is useful for cases where
      your dataset or corpus is huge and you only want to start with a small chunk
      until you get your models debugged.
    
      Parameters
      ----------
      * **ratio** a number between (0-1]; by default this is 1
    
      **Note** This removes any stored *dataset split* state

    combit 0.3.0
    Intuitive and concise processing of fixed-size Data Containers.
    combit.combination/parallel*SourceDoc + Usages
    Create component that represents the parallelization of the given components.
       If component A takes n inputs and produces m outputs, and B takes n' and produces
       m', the component (parallel [n n'] [A B]) will take (n + n') inputs and produce 
      (m + m') outputs.
      
       The first seq is necessary to determine where inputs should be split. Both parameters
       can be infinite seqs, which is very useful in creating components with unlimited inputs.

    aerial.bio.utils 2.0.0
    Various bioinformatic general utility tools
    aerial.bio.utils.files/chunk-genome-fnasSourceDoc + Usages
    Take the set of fnas in directory GENOME-FNA-DIR (presumably
       created by split-join-ncbi-fasta-file or similar) and aggregate
       them into a new smaller set of files, where each new file contains
       the contents of CHUNK-SIZE input files (with the possible exception
       of the last file having a smaller number).  This is useful for
       creating custom data sets for search.
      

    clj-jumanpp 0.1.0
    A Clojure library for idiomatic access to the Japanese Morphological Analyzer JUMAN++
    clj-jumanpp.core/features-conformerSourceDoc + Usages
    Transforms jumanpp's last feature field (意味情報) into a map for easier filtering in processing pipelines. While all features are split on whitespace, some are key-value based (separated with:), and some are single-value. Key-values are simply merged into a map, while single-value fields are keyed according to value and given true as their value.

    Accepts one or more strings; emits a `str` invocation that concatenates
    the string data and evaluated expressions contained within that argument.
    Evaluation is controlled using ~{} and ~() forms. The former is used for
    simple value replacement using clojure.core/str; the latter can be used to
    embed the results of arbitrary function invocation into the produced string.
    
    Examples:
      user=> (def v 30.5)
      #'user/v
      user=> (<< "This trial required ~{v}ml of solution.")
      "This trial required 30.5ml of solution."
      user=> (<< "There are ~(int v) days in November.")
      "There are 30 days in November."
      user=> (def m {:a [1 2 3]})
      #'user/m
      user=> (<< "The total for your order is $~(->> m :a (apply +)).")
      "The total for your order is $6."
      user=> (<< "Just split a long interpolated string up into ~(-> m :a (get 0)), "
               "~(-> m :a (get 1)), or even ~(-> m :a (get 2)) separate strings "
               "if you don't want a << expression to end up being e.g. ~(* 4 (int v)) "
               "columns wide.")
      "Just split a long interpolated string up into 1, 2, or even 3 separate strings if you don't want a << expression to end up being e.g. 120 columns wide."
      
    Note that quotes surrounding string literals within ~() forms must be
    escaped.

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cuerdas.core/<<SourceDoc + Usages
    Accepts one or more strings; emits a `str` invocation that
         concatenates the string data and evaluated expressions contained
         within that argument.  Evaluation is controlled using ~{} and ~()
         forms. The former is used for simple value replacement using
         clojure.core/str; the latter can be used to embed the results of
         arbitrary function invocation into the produced string.
    
         Examples:
    
             user=> (def v 30.5)
             #'user/v
             user=> (<< "This trial required ~{v}ml of solution.")
             "This trial required 30.5ml of solution."
             user=> (<< "There are ~(int v) days in November.")
             "There are 30 days in November."
             user=> (def m {:a [1 2 3]})
             #'user/m
             user=> (<< "The total for your order is $~(->> m :a (apply +)).")
             "The total for your order is $6."
             user=> (<< "Just split a long interpolated string up into ~(-> m :a (get 0)), "
                      "~(-> m :a (get 1)), or even ~(-> m :a (get 2)) separate strings "
                      "if you don't want a << expression to end up being e.g. ~(* 4 (int v)) "
                      "columns wide.")
             "Just split a long interpolated string up into 1, 2, or even 3 separate strings if you don't want a << expression to end up being e.g. 120 columns wide."
    
         Note that quotes surrounding string literals within ~() forms must be
         escaped.

    pretty 0.1.34
    Clojure library to help print things, prettily
    io.aviso.exception/expand-stack-traceSourceDoc + Usages
    Extracts the stack trace for an exception and returns a seq of expanded stack frame maps:
    
      :file String
      : file name
    
      :line Integer
      : line number as an integer, or nil
    
      :class String
      : complete Java class name
    
      :package String
      : Java package name, or nil for root package
    
      :simple-class String
      : simple name of Java class (without package prefix)
    
      :method String
      : Java method name
    
      :name String
      : Fully qualified Clojure name (demangled from the Java class name), or the empty string for non-Clojure stack frames
    
      :names seq of String
      : Clojure name split at slashes (empty for non-Clojure stack frames)

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.cli/parse-optsSourceDoc + Usages
    Parse command line args or the provided argument list. Returns a map of keys to
       vectors of repeated values. Named args begin with --keyname and are mapped to
       :keyname. Unnamed arguments are mapped to nil or default. Repeated named values can be
       specified by repeating a key or by using commas in the value. Single and double dashes
       are both supported though a single dash followed by word characters without internal
       dashes or an equal sign is assumed to be single character argument flags and are split
       accordingly.
    
       Example:
         (parse-opts ["foo" "-vD" "bar" "-no-wrap" "-color=blue,green" "--style=baroque" "-color=red"])
         => {:style ["baroque"], :color ["blue" "green" "red"], :no-wrap [""], :D [""], :v [""], nil ["foo" "bar"]}

    lamina 0.5.6
    event-driven data structures for clojure
    lamina.core.operators/distributorSourceDoc + Usages
    Returns a channel.
    
       Messages enqueued into this channel are split into multiple streams, grouped by
       (facet msg). When a new facet-value is encountered, (initializer facet ch)
       is called, allowing messages with that facet-value to be handled appropriately.
    
       If a facet channel is closed, it will be removed from the distributor, and
       a new channel will be generated when another message of that type is enqueued.
       This allows the use of (close-on-idle ch ...), if facet-values will change over
       time.
    
       Given messages with the form {:type :foo, :value 1}, to print the mean values of all
       types:
    
       (distributor
         {:facet       :type
          :initializer (fn [facet-value ch]
                         (siphon
                           (->> ch (map* :value) moving-average)
                           (sink #(println "average for" facet-value "is" %))))})

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.cli/parse-optsSourceDoc + Usages
    Parse command line args or the provided argument list. Returns a map of keys to
       vectors of repeated values. Named args begin with --keyname and are mapped to
       :keyname. Unnamed arguments are mapped to nil or default. Repeated named values can be
       specified by repeating a key or by using commas in the value. Single and double dashes
       are both supported though a single dash followed by word characters without internal
       dashes or an equal sign is assumed to be single character argument flags and are split
       accordingly.
    
       Example:
         (parse-opts ["foo" "-vD" "bar" "-no-wrap" "-color=blue,green" "--style=baroque" "-color=red"])
         => {:style ["baroque"], :color ["blue" "green" "red"], :no-wrap [""], :D [""], :v [""], nil ["foo" "bar"]}

    tawny-owl 2.0.0
    tawny-owl enables building OWL ontologies in a programmatic environment.
    tawny.owl/frameifySourceDoc + Usages
    Return a framified function.
    
      A frameified function is one that accepts keywords which take any
      number of arguments. These values are converted into a map.
    
      EXPLICIT-F is the function that will be called. It should accept arguments
      of form (ontology name map) where MAP is generated from the arguments to the
      framified function.
    
      FRAME-KEYS are the keywords which are valid for this function. Other values
      will raise an exception.
    
      HASHIFY is the function used to convert between the flat list of arguments
      and the map. By default, this will split at every keyword.
    
      The function returned has 'f-ontology' functionality; that is, if no
      ontology argument is supplied by the user, it will be provided elsewhere.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.application/split-mutationsSourceDoc + Usages
    Split a tx that contains mutations.
    
       Examples:
       [(f) (g)] => [[(f) (g)]]
       [(f) (g) (f) (k)] => [[(f) (g)] [(f) (k)]]
       [(f) (g) (f) (k) (g)] => [[(f) (g)] [(f) (k) (g)]]
    
       This function splits any mutation that uses the same dispatch symbol more than once (since returns from server go
       into a map, and that is the only way to get return values from both), and also when the mutations do not share abort
       IDs (so that mutations do not get grouped into a transaction that could cause them to get cancelled incorrectly).
    
       Returns a sequence that contains one or more transactions.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/split-items-ready-to-loadSourceDoc + Usages
    This function is used to split accidental colliding queries into separate network
      requests. The most general description of this issue is
      from two unrelated `load` calls when black-box composing functions. The two
      separate queries: One issues `[{:entitlements [:foo]}]`, and the other
      asks for `[{:entitlements [:bar]}]`. Untangled merges these into a single query
      [{:entitlements [:foo]} {:entitlements [:bar]}]. However, the response to a query
      is a map, and such a query would result in the backend parser being called twice (once per key in the subquery)
      but one would stomp on the other. Thus, this function ensures such accidental collisions are
      not combined into a single network request.

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    io.aviso.exception/expand-stack-traceSourceDoc + Usages
    Extracts the stack trace for an exception and returns a seq of expanded stack frame maps:
    
      :file String
      : file name
    
      :line Integer
      : line number as an integer, or nil
    
      :class String
      : complete Java class name
    
      :package String
      : Java package name, or nil for root package
    
      :simple-class String
      : simple name of Java class (without package prefix)
    
      :method String
      : Java method name
    
      :name String
      : Fully qualified Clojure name (demangled from the Java class name), or the empty string for non-Clojure stack frames
    
      :names seq of String
      : Clojure name split at slashes (empty for non-Clojure stack frames)

    metabase 0.1.0
    Metabase Community Edition
    metabase.db/migrations-linesSourceDoc + Usages
    Return a sequnce of DDL statements that should be used to perform migrations for LIQUIBASE.
    
       MySQL gets snippy if we try to run the entire DB migration as one single string; it seems to only like it if we run one statement at a time;
       Liquibase puts each DDL statement on its own line automatically so just split by lines and filter out blank / comment lines. Even though this
       is not neccesary for H2 or Postgres go ahead and do it anyway because it keeps the code simple and doesn't make a significant performance difference.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/split-items-ready-to-loadSourceDoc + Usages
    This function is used to split accidental colliding queries into separate network
      requests. The most general description of this issue is
      from two unrelated `load` calls when black-box composing functions. The two
      separate queries: One issues `[{:entitlements [:foo]}]`, and the other
      asks for `[{:entitlements [:bar]}]`. Untangled merges these into a single query
      [{:entitlements [:foo]} {:entitlements [:bar]}]. However, the response to a query
      is a map, and such a query would result in the backend parser being called twice (once per key in the subquery)
      but one would stomp on the other. Thus, this function ensures such accidental collisions are
      not combined into a single network request.

    clj-schulze 0.9.4
    A Clojure implementation of the Schulze voting method
    com.github.bdesham.clj-schulze/total-pairwise-defeatsSourceDoc + Usages
    Takes a (counted) hash of ballots and returns a counted hash of the pairwise
      defeats.
      
      The steps this function uses are:
    
      1. Turn the input--a hash from ballots to occurrences--into a vector of
      vectors where the first elements are the ballots and the second elements are
      the numbers of occurrences.
    
      2. Look at each first element (i.e. ballot) and call `pairwise-defeats` on it.
    
      3. Split the vectors so that instead of a *list* of pairwise defeats being
      associated with a number of occurrences, we associate each pairwise defeat
      *individually* with a number of occurrences.
    
      4. Combine all of the resulting hashes so that we have the total number of
      occurrences for each pairwise defeat, adding any missing pairs along the way.

    lamina 0.5.6
    event-driven data structures for clojure
    lamina.core.operators/distribute-aggregateSourceDoc + Usages
    A mechanism similar to a SQL `group by` or the split-apply-combine strategy for data analysis.
    
       For each message from `channel`, the value returned by `(facet msg)` will be examined, and the
       message will be routed to a channel that consumes all messages with that facet value.  If no
       such channel exists, it will be generated by `(generator facet-value facet-channel)`, which takes
       the facet-value and associated channel, and returns an output channel which will be merged with
       the output of all other facet channels.
    
       The output of each facet channel is assumed to be periodic.  The `:period` may be specified, but
       is not required.
    
       Returns a channel which will periodically emit a map of facet-value onto the output of the generated
       facet-channel.
    
       Example:
    
         (distribute-aggregate
           {:facet     :uri
            :generator (fn [uri ch]
                             (rate ch))}
           ch)
    
       will return a channel which periodically emits a map of the form
    
              {"/abc" 2
               "/def" 3}

    pod 2.7.2
    Boot pod module–this is included with all pods.
    boot.from.io.aviso.exception/expand-stack-traceSourceDoc + Usages
    Extracts the stack trace for an exception and returns a seq of expanded stack frame maps:
    
      :file String
      : file name
    
      :line Integer
      : line number as an integer, or nil
    
      :class String
      : fully qualified Java class name
    
      :package String
      : Java package name, or nil for root package
    
      :simple-class String
      : simple name of Java class (without package prefix)
    
      :method String
      : Java method name
    
      :is-clojure?
      : true if this represents a Clojure function call, rather than a Java
        method invocation.
    
      :name String
      : Fully qualified Clojure name (demangled from the Java class name), or the empty string for non-Clojure stack frames
    
      :names seq of String
      : Clojure name split at slashes (empty for non-Clojure stack frames)

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/split-items-ready-to-loadSourceDoc + Usages
    This function is used to split accidental colliding queries into separate network
      requests. The most general description of this issue is
      from two unrelated `load` calls when black-box composing functions. The two
      separate queries: One issues `[{:entitlements [:foo]}]`, and the other
      asks for `[{:entitlements [:bar]}]`. Fulcro merges these into a single query
      [{:entitlements [:foo]} {:entitlements [:bar]}]. However, the response to a query
      is a map, and such a query would result in the backend parser being called twice (once per key in the subquery)
      but one would stomp on the other.
    
      The other potential collision is if a load includes an abort ID. In this case such a load should not be batched
      with others because aborting it would take others down with it.
    
      Thus, this function ensures such accidental collisions are not combined into a single network request.
    
      This functions returns a list of the load items that can be batched (from the beginning, in order) and the
      remainder of the items which must be deferred to another request.

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.parser/inclusion-directive-lineSourceDoc + Usages
    input: directive to call/include another Drake workflow. ie.,
       %include nested.d
       output: same as if the lines of the nested file were copy and pasted into
       the parent workflow.  If call was used though, then the variable
       definitions in the nested workflow will not exist after the call is
       completed.
    
       This is split into 2 parts, inclusion-directive-line and inclusion-directive-helper,
       mainly because we need to call parse-state during the rule-product
       manipulation phase, and then we need to save vars from the %include into
       our state stuct. However, we can only set the state vars during the rule
       matching phase, which comes before the product manipulation phase when using
       "complex". Thus we add a wrapper rule to set the variable.

    drake 1.0.3
    Drake: the data processing workflow tool (a.k.a. 'make for data')
    drake.parser/inclusion-directive-lineSourceDoc + Usages
    input: directive to call/include another Drake workflow. ie.,
       %include nested.d
       output: same as if the lines of the nested file were copy and pasted into
       the parent workflow.  If call was used though, then the variable
       definitions in the nested workflow will not exist after the call is
       completed.
    
       This is split into 2 parts, inclusion-directive-line and inclusion-directive-helper,
       mainly because we need to call parse-state during the rule-product
       manipulation phase, and then we need to save vars from the %include into
       our state stuct. However, we can only set the state vars during the rule
       matching phase, which comes before the product manipulation phase when using
       "complex". Thus we add a wrapper rule to set the variable.

    lucid.core.inject 1.4.6
    tools for code clarity
    lucid.core.inject/inject-split-argsSourceDoc + Usages
    splits args for the inject namespace
       (inject-split-args
       '[clojure.core >
         (clojure.pprint pprint)
     
         clojure.core
         (lucid.reflection    .> .? .* .% .%>)
     
        a
         (clojure.repl apropos source doc find-doc
                       dir pst root-cause)
         (lucid.reflection [>ns ns] [>var var])
         (clojure.java.shell :refer [sh])
         (lucid.core.inject :exclude [inject-single])
         (lucid.package :all)
         (lucid.core.debug)])
       => '[{:ns clojure.core, :prefix >,
            :imports [{:ns clojure.pprint, :op :refer,
                       :arr (pprint)}]}
           {:ns clojure.core,
            :imports [{:ns lucid.reflection, :op :refer,
                       :arr (.> .? .* .% .%>)}]}
           {:ns a,
            :imports [{:ns clojure.repl, :op :refer,
                       :arr (apropos source doc find-doc dir pst root-cause)}
                      {:ns lucid.reflection, :op :refer,
                       :arr ([>ns ns] [>var var])}
                      {:ns clojure.java.shell, :op :refer,
                       :arr [sh]}
                      {:ns lucid.core.inject, :op :exclude,
                       :arr [inject-single]}
                      {:ns lucid.package, :op :exclude, :arr ()}
                      {:ns lucid.core.debug, :op :exclude, :arr ()}]}]

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.ui.bootstrap3/labeled-inputSourceDoc + Usages
    An input with a label. All of the attrs apply to the input itself. You must supply a type and id for the
      field to work correctly. DO NOT USE for checkbox or radio.
    
      The additional attributes are supported:
    
      :split - A number from 1 to 11. The number of `sm` columns to allocate to the field label. If not specified, the
      label will be above the input. The parent must use the `.form-horizontal` class.
      :help - A string. If supplied, displayed as the help text for the field. NOT shown if warning, error, or success are set.
    
      You should only ever supply zero or one of the following:
      :warning - A boolean or string. If set as a string, that content replaces the help text.
      :error - A boolean or string. If set as a string, that content replaces the help text.
      :success - A boolean or string. If set as a string, that content replaces the help text.
      

    lucid.flight.inject 1.1.0
    tools for clarity
    lucid.flight.inject/inject-split-argsSourceDoc + Usages
    splits args for the inject namespace
       (inject-split-args
       '[clojure.core >
         (clojure.pprint pprint)
     
         clojure.core
         (lucid.flight.reflection    .> .? .* .% .%>)
     
        a
         (clojure.repl apropos source doc find-doc
                       dir pst root-cause)
         (lucid.flight.reflection [>ns ns] [>var var])
         (clojure.java.shell :refer [sh])
         (lucid.flight.inject :exclude [inject-single])
         (lucid.flight.maven :all)
         (lucid.flight.debug)])
       => '[{:ns clojure.core, :prefix >,
            :imports [{:ns clojure.pprint, :op :refer,
                       :arr (pprint)}]}
           {:ns clojure.core,
            :imports [{:ns lucid.flight.reflection, :op :refer,
                       :arr (.> .? .* .% .%>)}]}
           {:ns a,
            :imports [{:ns clojure.repl, :op :refer,
                       :arr (apropos source doc find-doc dir pst root-cause)}
                      {:ns lucid.flight.reflection, :op :refer,
                       :arr ([>ns ns] [>var var])}
                      {:ns clojure.java.shell, :op :refer,
                       :arr [sh]}
                      {:ns lucid.flight.inject, :op :exclude,
                       :arr [inject-single]}
                      {:ns lucid.flight.maven, :op :exclude, :arr ()}
                      {:ns lucid.flight.debug, :op :exclude, :arr ()}]}]

    preflex 0.4.0
    Metrics, Instrumentation and Resilience for Clojure
    preflex.metrics/make-rolling-percentile-collectorSourceDoc + Usages
    Create bucketed rolling percentile collector. Optional args default to making a per-second counter.
      Arguments:
        deref-key    (keyword) key to associate the count with (upon deref)
        percentiles  (seqable) list of percentiles to calculate
        bucket-count (integer) number of buckets in the buffer
      Options:
        :bucket-interval (integer)  diff between min and max possible event IDs in any bucket (default 1000 = 1 second)
        :bucket-capacity (integer) max number of values in every bucket
        :buckets-key     (keyword)  key to associate the buckets data in the deref result (nil omits bucket data)
        :deref-head?     (boolean)  query the current bucket during deref? (false by default)
        :event-id-fn     (function) no-arg fn to return latest event ID (returns current time in milliseconds by default)
        :shard-count     (integer)  number of shards to split write-load across

    preflex 0.4.0
    Metrics, Instrumentation and Resilience for Clojure
    preflex.metrics/make-rolling-max-collectorSourceDoc + Usages
    Create bucketed rolling max-value collector. Optional args default to making a per-second counter.
      Arguments:
        deref-key    (keyword) key to associate the count with (upon deref)
        bucket-count (integer) number of buckets in the buffer
      Options:
        :bucket-interval (integer)  diff between min and max possible event IDs in any bucket (default 1000 = 1 second)
        :buckets-key     (keyword)  key to associate the buckets data in the deref result (nil omits bucket data)
        :deref-head?     (boolean)  query even the current bucket during deref? (false by default)
        :event-id-fn     (function) no-arg fn to return latest event ID (returns current time in milliseconds by default)
        :shard-count     (integer)  number of shards to split write-load across

    preflex 0.4.0
    Metrics, Instrumentation and Resilience for Clojure
    preflex.metrics/make-rolling-integer-counterSourceDoc + Usages
    Create bucketed rolling count collector. Optional args default to making a per-second counter.
      Arguments:
        deref-key    (keyword) key to associate the count with (upon deref)
        bucket-count (integer) number of buckets in the buffer
      Options:
        :bucket-interval (integer)  diff between min and max possible event IDs in any bucket (default 1000 = 1 second)
        :buckets-key     (keyword)  key to associate the buckets data in the deref result (nil omits bucket data)
        :deref-head?     (boolean)  query even the current/head bucket during deref? (false by default)
        :event-id-fn     (function) no-arg fn to return latest event ID (returns current time in milliseconds by default)
        :shard-count     (integer)  number of shards to split write-load across

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.masai-sorted-layer/specialized-writerSourceDoc + Usages
    If your update function has special semantics that allow it to be distributed over multiple
       paths more efficiently than reading the whole node, applying the function, and then writing to
       each format, you can implement a method for specialized-writer. For example, useful.utils/adjoin
       can be split up by matching up the paths in the adjoin-arg and in the layout.
    
       layout is a sequence of [path, format] pairs, which are computed for your convenience: if you
       preferred, you could recalculate them from layer and keyseq.  You should return a retro IOValue
       for writing to the layer the result of (apply update-in layer keyseq f args). See the contract
       for jiraph.layer/update-in-node - you are effectively implementing an updater for a particular
       function rather than a layer.
    
       Note that it is acceptable to return nil instead of a function, if you find the keyseq or
       layout means you cannot do any optimization.

    aerial.utils 1.2.0
    Utility 'tool belt' of functions for common tasks; trees; clustering; probability,
    aerial.utils.math.clustering/split-worst-clusterSourceDoc + Usages
    Clusters a cluster map as given by function CLUSTER (for which
       see).  The functions distfn and avgfn are the distance and 'mean'
       functions used to build clusters.
    
       Clusters is assumed to be smaller in count than it 'should' be.
       Using an error measure, which here is SSE (see ith-sum-sqr-err and
       sum-sqr-err), clusters has a worst cluster Ci.  Split Ci by first
       sorting its points by their distance from cmi, the center of Ci.
       Then remove the points within WRADIUS percent of the furthest point
       and place in new cluster wCi.  Remove Ci from clusters and add the
       pair of clusters from splitting Ci:
    
       new-clusters = clusters - Ci + (Ci - wCi) + wCi
    
       Return new-clusters.
      

    Extracts the stack trace for an exception and returns a seq of expanded stack frame maps:
    
      :file String
      : file name
    
      :line Integer
      : line number as an integer, or nil
    
      :class String
      : fully qualified Java class name
    
      :package String
      : Java package name, or nil for root package
    
      :simple-class String
      : simple name of Java class (without package prefix)
    
      :method String
      : Java method name
    
      :is-clojure?
      : true if this represents a Clojure function call, rather than a Java
        method invocation.
    
      :name String
      : Fully qualified Clojure name (demangled from the Java class name), or the empty string for non-Clojure stack frames
    
      :names seq of String
      : Clojure name split at slashes (empty for non-Clojure stack frames)

    eisen 0.1.0
    A Language for Programmable Applications
    blancas.eisen.core/init-eisenSourceDoc + Usages
    Initializes the Eisen library. This is a convenience function that
       a host program may omit or override with custom calls.
    
       (1) It installs the following commands into the Eisen langauge:
    
           * asString
           * case
           * cond
           * doseq
           * dosync
           * for
           * io!
           * locking
           * loop
           * sync
           * when
           * whenFirst
           * while
           * withOpen
           * withString
    
       (2) Installs the following imports, to be applied to any Eisen module
           so that common Clojure names are available automatically and with
           in idiomatic camel case instead of embedded dashes.
    
       clojure.core
          assocIn
          dropWhile
          fileSeq
          getIn
          groupBy
          hashMap
          hashSet
          lazySeq
          lineSeq
          mergeWith
          notAny?
          notEmpty
          notEvery?
          partitionAll
          partitionBy
          prStr
          printStr
          printlnStr
          reFind
          reGroups
          reMatcher
          reMatches
          rePattern
          reSeq
          readLine
          refSet
          selectKeys
          sortBy
          sortedMap
          sortedMapBy
          sortedSet
          sortedSetBy
          splitAt
          splitWith
          takeLast
          takeNth
          takeWhile
          treeSeq
          updateIn
          xmlSeq
    
       clojure.java.io
          file 
          reader
          writer
          inputStream
          outputStream
    
       clojure.string
          blank? 
          join 
          split 
          trim
          splitLines
    
       clojure.xml
          parse

    eisen 0.1.0
    A Language for Programmable Applications
    blancas.eisen.core/init-eisenSourceDoc + Usages
    Initializes the Eisen library. This is a convenience function that
       a host program may omit or override with custom calls.
    
       (1) It installs the following commands into the Eisen langauge:
    
           * asString
           * case
           * cond
           * doseq
           * dosync
           * for
           * io!
           * locking
           * loop
           * sync
           * when
           * whenFirst
           * while
           * withOpen
           * withString
    
       (2) Installs the following imports, to be applied to any Eisen module
           so that common Clojure names are available automatically and with
           in idiomatic camel case instead of embedded dashes.
    
       clojure.core
          assocIn
          dropWhile
          fileSeq
          getIn
          groupBy
          hashMap
          hashSet
          lazySeq
          lineSeq
          mergeWith
          notAny?
          notEmpty
          notEvery?
          partitionAll
          partitionBy
          prStr
          printStr
          printlnStr
          reFind
          reGroups
          reMatcher
          reMatches
          rePattern
          reSeq
          readLine
          refSet
          selectKeys
          sortBy
          sortedMap
          sortedMapBy
          sortedSet
          sortedSetBy
          splitAt
          splitWith
          takeLast
          takeNth
          takeWhile
          treeSeq
          updateIn
          xmlSeq
    
       clojure.java.io
          file 
          reader
          writer
          inputStream
          outputStream
    
       clojure.string
          blank? 
          join 
          split 
          trim
          splitLines
    
       clojure.xml
          parse

    tabular_functions 0.1.5
    Functions to perform tabular transformations for use in Grafter pipelines
    tabular_functions.pipeline/split-columnSourceDoc + Usages
    Given a dataset, column name and separator splits specified column into multiple by separator. New columns get 
     names of a form [original-column-name]_splitted_0, [original-column-name]_splitted_1, ...
    
                       
              Given original dataset:
    
                        | :name |                       :address |            :email |
                        |-------+--------------------------------+-------------------|
                        | Alice | New York, Harrison Street, 507 | alice@example.com |
                        |   Bob |      Richmond, Main Street, 17 |   bob@example.com |
                        |  Mary | NY, Harrison Street, 29, H0512 |  mary@example.com |
    
    
       
    
              function returns the following result:
    
              `(split-column :address #", ") ;  =>`
    
    
                       | :name | :address_splitted_0 | :address_splitted_1 | :address_splitted_2 | :address_splitted_3 |            :email |
                       |-------+---------------------+---------------------+---------------------+---------------------+-------------------|
                       | Alice |            New York |     Harrison Street |                 507 |                     | alice@example.com |
                       |   Bob |            Richmond |         Main Street |                  17 |                     |   bob@example.com |
                       |  Mary |                  NY |     Harrison Street |                  29 |               H0512 |  mary@example.com |
    
     

    jaws 0.2.0
    Simple tools/wrapper for Amazon AWS JDK API use. Unlikely to be
    jaws.native/report-instancesSourceDoc + Usages
    Print a information about instances.
       The default is to print one line of information per instance, unless options
       are specified for other details.
    
       Options:
       :indent all lines with the indicated (minimum) number of leading spaces
               indentation desired (default *indent*).  note that secondary lines (if
               more than one line per instance is printed) are indented an
               additional indent-incr spaces.
       :indent-incr amount to additionally indent secondary data lines (for
                    options where more than one line per instance is printed. Default 2.
       :instances An Instance or collection thereof.  If neither this nor :ids
                  is speciied, (describe-instances is called to retrieve data.
                  If both are specified, the resulting instances from each field are used
                  (all together).  Note that you can turn instance IDs to instances
                  via 'describe-instances'.
       :ids An instance ID or collection thereof, passed to 'describe-instances'.
       :fields Set of fields (information) to display in addition to instance id.
               Defaults to: #{:ImageId :VpcId :SubnetId :PublicDnsName :KeyName :State :InstanceType :SecurityGroups :Tags}
               Additional fields include: :VolumeIds, :InstanceProfile, :LaunchTime, :StoreType
               :PrivateIpAddress :PrivateDnsName :PublicIpAddress.
       :include Set of additional fields to display, defaults to #{}
       :exclude Set of fields to exclude from the display, defaults to #{}.
       :split-after A field keyword, or collection of field keywords, after which a 'println' and indent
                    will occur to break the report into multiple lines per instance.
                    By default there is only one line per instance for easier output grepping.
                    Rather pointless if you use the last field as a split field, unless you want a blank line
                    between each instance' report.  JDT likes :InstanceType for this keyword.
       Note that presently you can't specify the order of fields.

    hugsql-core 0.4.9
    HugSQL core functionality without adapter dependencies
    hugsql.core/def-db-fnsSourceDoc + Usages
    Given a HugSQL SQL file, define the database
       functions in the current namespace.
    
       Usage:
    
       (def-db-fns file options?)
    
       where:
        - file is a string file path in your classpath,
          a resource object (java.net.URL),
          or a file object (java.io.File)
        - options (optional) hashmap:
          {:quoting :off(default) | :ansi | :mysql | :mssql
           :adapter adapter }
    
       :quoting options for identifiers are:
         :ansi double-quotes: "identifier"
         :mysql backticks: `identifier`
         :mssql square brackets: [identifier]
         :off no quoting (default)
    
       Identifiers containing a period/dot . are split, quoted separately,
       and then rejoined. This supports myschema.mytable conventions.
    
       :quoting can be overridden as an option in the calls to functions
       created by def-db-fns.
    
       :adapter specifies the HugSQL adapter to use for all defined
       functions. The default adapter used is
       (hugsql.adapter.clojure-java-jdbc/hugsql-adapter-clojure-java-jdbc)
       when :adapter is not given.
    
       See also hugsql.core/set-adapter! to set adapter for all def-db-fns
       calls.  Also, :adapter can be specified for individual function
       calls (overriding set-adapter! and the :adapter option here).

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.bootstrap3/labeled-inputSourceDoc + Usages
    An input with a label. All of the attrs apply to the input itself. You must supply a type and id for the
      field to work correctly. DO NOT USE for checkbox or radio.
    
      The additional attributes are supported:
    
      :split - A number from 1 to 11. The number of `sm` columns to allocate to the field label. If not specified, the
      label will be above the input. The parent must use the `.form-horizontal` class.
      :help - A string. If supplied, displayed as the help text for the field. NOT shown if warning, error, or success are set.
      :input-generator An (optional) function of `props -> input` to be called to generate the DOM input. It will receive a clj map
        of properties and should return an input that has those minimum properties. It can, of course, augment those.
    
      You should only ever supply zero or one of the following:
      :warning - A boolean or string. If set as a string, that content replaces the help text.
      :error - A boolean or string. If set as a string, that content replaces the help text.
      :success - A boolean or string. If set as a string, that content replaces the help text.
      

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.email/mailerSourceDoc + Usages
    Returns a mailer, which is a function invoked with an address or a sequence
      of addresses and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends email about them.
    
      ```clojure
      (def email (mailer))
      ```
    
      This mailer uses the local sendmail.
    
      ```clojure
      (changed :state
        (email "xerxes@trioptimum.org" "shodan@trioptimum.org"))
      ```
    
      The first argument are SMTP options like :host, :port, :user, :pass, :tls,
      and :ssl. The second argument is a map of default message options, like :from
      or :subject.
    
      ```clojure
      (def email (mailer {:host "mail.relay"}
                         {:from "riemann@trioptimum.com"}))
    
      ```
    
      If you provide a single map, mailer will split the SMTP options out for you.
    
      ```clojure
      (def email (mailer {:host "mail.relay"
                          :user "foo"
                          :pass "bar"
                          :from "riemann@trioptimum.com"}))
      ```
    
      smtp-opts and msg-opts are passed to postal. For more documentation, see
      https://github.com/drewr/postal
    
      By default, riemann uses (subject events) and (body events) to format emails.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def email (mailer {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.email/mailerSourceDoc + Usages
    Returns a mailer, which is a function invoked with an address or a sequence
      of addresses and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends email about them.
    
      ```clojure
      (def email (mailer))
      ```
    
      This mailer uses the local sendmail.
    
      ```clojure
      (changed :state
        (email "xerxes@trioptimum.org" "shodan@trioptimum.org"))
      ```
    
      The first argument are SMTP options like :host, :port, :user, :pass, :tls,
      and :ssl. The second argument is a map of default message options, like :from
      or :subject.
    
      ```clojure
      (def email (mailer {:host "mail.relay"}
                         {:from "riemann@trioptimum.com"}))
    
      ```
    
      If you provide a single map, mailer will split the SMTP options out for you.
    
      ```clojure
      (def email (mailer {:host "mail.relay"
                          :user "foo"
                          :pass "bar"
                          :from "riemann@trioptimum.com"}))
      ```
    
      smtp-opts and msg-opts are passed to postal. For more documentation, see
      https://github.com/drewr/postal
    
      By default, riemann uses (subject events) and (body events) to format emails.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def email (mailer {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/get-account-data (cljs)SourceDoc + Usages
    Similar to `get-transfers`, just a bit more comprehensive in the sense that
      it also returns the addresses, transfers, inputs and balance that are
      associated and have been used with your account (seed). This function is
      useful in getting all the relevant information of your account. If you want to
      have your transfers split into received / sent, you can use the utility
      function `categorize-transfers`.
    
      Arguments:
      iota - IOTA client instance
      seed - Tryte-encoded seed. It should be noted that this seed is not
             transferred
      options - optional map with:
        :start - Starting key index for search
        :end - Ending key index for search
        :security - Security level to be used for the private key / addresses,
                    which is used for getting all associated transfers
      callback - Optional callback with error and result
    
      Returns map of your account data in the following format:
      ```
    
      {:latest-address "" ; Latest, unused address which has no transactions in
                            ; the tangle
       :addresses     []    ; List of all used addresses which have transactions
                            ; associated with them
       :transfers     []    ; List of all transfers associated with the addresses
       :inputs        []    ; List of all inputs available for the seed. Follows the
                            ; `get-inputs` format of `address`, `balance`,
                            ; `security` and `key-index`
       :balance       0}    ; Latest confirmed balance
      ```

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/get-transfers (cljs)SourceDoc + Usages
    Returns the transfers which are associated with a seed. The transfers are
      determined by either calculating deterministically which addresses were
      already used, or by providing a list of indexes to get the addresses and the
      associated transfers from. The transfers are sorted by their timestamp. It
      should be noted that, because timestamps are not enforced in IOTA, that this
      may lead to incorrectly sorted bundles (meaning that their chronological
      ordering in the Tangle is different).
    
      If you want to have your transfers split into received / sent, you can use the
      utility function `iota-utils/categorize-transfers`.
    
      Arguments:
      seed - string tryte-encoded seed. It should be noted that this seed is not
             transferred
      options - optional map with following keys:
    
        :start - int Starting key index for search
        :end - int Ending key index for search
        :security - int Security level to be used for the private key / addresses,
                        which is used for getting all associated transfers.
        :inclusion-states - bool If true, it gets the inclusion states of the
                                 transfers.
      callback - fn Optional callback.
    
      Returns an array of transfers. Each array is a bundle for the entire
      transfer.

    preflex 0.4.0
    Metrics, Instrumentation and Resilience for Clojure
    preflex.metrics/make-rolling-boolean-counterSourceDoc + Usages
    Create bucketed rolling count collector for truthy and falsy values respectively. Optional args default to making a
      per-second counter.
      Arguments:
        deref-truthy-key (keyword) key to associate the truthy count with (upon deref)
        deref-falsy-key  (keyword) key to associate the falsy count with (upon deref)
        bucket-count     (integer) number of buckets in the buffer
      Options:
        :bucket-interval (integer)  diff between min and max possible event IDs in any bucket (default 1000 = 1 second)
        :buckets-truthy-key (keyword)  key to associate the truthy buckets data in the deref result (nil omits bucket data)
        :buckets-falsy-key  (keyword)  key to associate the falsy buckets data in the deref result (nil omits bucket data)
        :deref-head?     (boolean)  query even the current bucket during deref? (false by default)
        :event-id-fn     (function) no-arg fn to return latest event ID (returns current time in milliseconds by default)
        :shard-count     (integer)  number of shards to split write-load across

    shrimp-chain 0.1.1
    A ClojureScript library built on top of shrimp providing macros to chain async functions.
    shrimp-chain.macros/chainSourceDoc + Usages
    Convert let, do, ->, ->>, cond->, cond->> to work with async functions.
    
      Build a chain of expressions where by default each one waits the realization
      of the previous one before executing and aborts execution if receives an error.
      Expressions could be async function invocations where the return value is a
      redlobster promise, like an async Node.js API call wrapped with chain-node,
      or a put!/take! to/from a shrimp channel.
    
      Examples:
    
        (chain []
          (let [content (chain-node (.read fs "file"))
                lines (split-lines content)]
            (println (first lines))))
    
        (chain []
          (-> shrimp-channel
              take!
              println))
    
      Each expression could be wrapped in a directive, which is like a function call,
      when not specified an implicit :chain/wait directive is assumed.
      The previous examples are equivalent to these:
    
        (chain []
          (let [content (:chain/wait (chain-node (.read fs "file")))
                lines (:chain/wait (split-lines content))]
            (println (first lines))))
    
        (chain []
          (-> (:chain/wait shrimp-channel)
              (:chain/wait take!)
              (:chain/wait println)))
    
      Allowed directives include:
    
        - :chain/go
    
          This tells the chain that execution could be immediate, but the result
          must be provided to the next waiting expression.
    
            (chain []
              (let [content1 (:chain/go (chain-node (.read fs "file1")))
                    content2 (:chain/go (chain-node (.read fs "file2")))
                    contents (str content1 content2)]
                (println contents)))
    
          In the example above both async reading execute immediately but the
          following expression runs only when both have returned with success and
          the values are bound to the symbols content1 and content2.
          Because :chain/go expressions run immediately, local bindings cannot be
          used inside these expressions, in the previous example the expression for
          content2 cannot refer to content1, if it is necessary to refer to content1
          then :chain/wait should be used (or nothing as it is the default).
          Because execution happens first, all calls to :chain/go should be placed
          at the beginning of the chain, to avoid confusion.
          :chain/go directives are not allowed in threading macros as it would make
          no sense since each expression needs the result of the previous one.
    
        - :chain/fork
    
          This directive is useful to perform side effects but only if the previous
          operations were successful.
          Expressions wrapped with :chain/fork wait for the results of preceding
          operations and execute only if error is nil, as with :chain/wait all
          preceding bindings are available.
          The return value is nil and the chain is advanced without waiting for the
          result of the fork expression.
          The result carried by the chain will remain bound to the return value of
          the expression preceding :chain/fork, this implies that this directive is
          allowed in threading macros too.
    
            (chain []
              (let [content (chain-node (.read fs "file"))
                    _ (:chain/fork (println (str "file loaded, content: " content)))
                    lines (split-lines content)]
                (println (first lines))))
    
            (chain []
              (->> shrimp-channel
                   take!
                   ; Thread in the result of take!, ignore the result of this expr.
                   ; Immediately jump to println and thread in the result of take!.
                   (:chain/fork (prn :take-value))
                   println))
    
            (chain []
              (do (chain-node (.write fs "file" "foo content"))
                  ; Possibly slow async operation, go to next expression immediately,
                  ; Ignore possible errors for this call.
                  (:chain-fork (chain-node (.write fs "log-file" "file content updated")))
                  [:foobar]))
    
        - :chain/end
    
          This directive must be the last expression in the chain and is useful to
          implement a custom handler for the chain that is *always* executed.
          The chain carries around a ChainSignal record containing :result and :error
          fields (among others), the function wrapped by :chain/end will receive two
          arguments, an id for the end expression (for logging purposes) and the
          ChainSignal record.
          The namespace shrimp-chain.core defines two handlers: <-result and <-error,
          these handlers extracts respectively the :result and :error field.
    
            (chain []
              (let [content (chain-node (.read fs "file"))
                    lines (split-lines content)
                    err (:chain/end <-error)]
                (when-not err
                  (println (first lines)))))
    
          In the chain-let macro the body is executed even if the chain was partially
          aborted because of an error, the reason is that it might be possible to
          recover from the error.
          The directive :chain/end could be used to explicitly check for an error
          like in the example above.
          The :chain/end could be used to terminate a threading macro, the handler
          function is *not* threaded and the final result of the chain will be
          whatever the handler returns:
    
            (chain []
              (-> shrimp-channel
                  take!
                  (:chain/end (fn [_ {:keys [result]}]
                                (println "end handler returning the result")
                                result))))
    
            (chain []
              (cond-> shrimp-channel
                true take!
                false (put! :foo)
                true (:chain/end (fn [_ {:keys [error result]}]
                                   (if error
                                     :default-value
                                     result)))))
    
      A chain invocation is an async block that returns a redlobster promise, hence
      chains allow composition:
    
        (chain []
          (let [content (chain-node (.read fs "file"))
                chan-res (chain []
                           (-> shrimp-channel
                               take!
                               pr-str))
                lines (split-lines content)]
            (println (str chan-res " " (first lines)))))
    
      The chain macro accepts three optional arguments as init options:
    
        - A chain-id, e.g. a keyword, that is bound to the :chain-id field of the
          ChainSignal record, and could be useful for logging.
    
        - A logging function that receives the ChainSignal record at each step of the
          chain, its return value is ignored and the ChainSignal is unchanged.
          Currently to log the last step of the chain it is necessary to add a
          :chain/end directive, e.g. (:chain/end <-result).
    
        - A transformer function that receives the ChainSignal at each step,
          what is passed to the next step is the result of applying transformer to
          the ChainSignal. Using this is probably a bad idea in most cases.
    
      All directives accept an optional step-id as first argument that is assigned
      to the :step-id field of the ChainSignal.
    
        (chain [:log-chain
                (fn [{:keys [chain-id step-id]}]
                  (prn [chain-id step-id]))]
    
          (let [content1 (:chain/go :read1 (chain-node (.read fs "file1")))
                content2 (:chain/go :read2 (chain-node (.read fs "file2")))
                contents (:chain/wait :str (str content1 content2))
                err (:chain/end <-error)]
            (when-not err
              (println contents))))
    
        => [:log-chain :chain/init]
        => [:log-chain :read1]
        => [:log-chain :read2]
        => [:log-chain :str]
        => ...
      

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.twilio/twilioSourceDoc + Usages
    Returns a messenger, which is a function invoked with a phone number or a sequence
      of phone numbers and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends a message about them.
    
      ```clojure
      (def messenger (twilio))
      (def text (messenger "+15005550006" "+15005550006"))
      ```
    
      This messenger sends sms out via twilio using the twilio http api. When used
      it outputs the http response recieved from twilio.
    
      ```clojure
      (changed :state
        #(info "twilio response" (text %)))
      ```
    
      The first argument is a map of the twilio options :account and :key.
      The second argument is a map of default message option.
    
      ```clojure
      (def text (twilio {:account "id" :service-key "key"}
                        {:from "+15005550006"}))
      ```
    
      Message options can be :
    
      - `:from`                    A twilio phone number
      - `:messaging-service-sid`   The 34 character unique id of the Messaging Service you want to associate with this Message
      - `:media-url`               The URL of the media you wish to send out with the message.
      - `:status-callback`         A URL that Twilio will POST to each time your message status changes to one of the following: queued, failed, sent, delivered, or undelivered
      - `:application-sid`         Twilio will POST MessageSid as well as MessageStatus=sent or MessageStatus=failed to the URL in the MessageStatusCallback property of this Application
      - `:max-price`               The total maximum price up to the fourth decimal (0.0001) in US dollars acceptable for the message to be delivered
      - `:provide-feedback`        Set this value to true if you are sending messages that have a trackable user action and you intend to confirm delivery of the message using the Message Feedback API
    
      Full API documentation can be found here : https://www.twilio.com/docs/api/rest/sending-messages
    
      If you provide a single map, the messenger will split the twilio options out
      for you.
    
      ```clojure
      (def text (twilio {:account "id"
                         :service-key "key"
                         :from "+15005550006"}))
      ```
    
      By default, riemann uses (body events) to format messages.
      You can set your own body formatter functions by including :body in msg-opts.
      These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def text (twilio {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.mailgun/mailgunSourceDoc + Usages
    Returns a mailer, which is a function invoked with an address or a sequence
      of addresses and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends email about them.
    
      ```clojure
      (def mailer (mailgun))
      (def email (mailer "xerxes@trioptimum.org" "shodan@trioptimum.org"))
      ```
    
      This mailer sends email out via mailgun using the mailgun http api. When used
      it outputs the http response recieved from mailgun.
    
      ```clojure
      (changed :state
        #(info "mailgun response" (email %)))
      ```
    
      The first argument is a map of the mailgun options :sandbox and :service-key.
      The second argument is a map of default message options, like :from,
      :subject, or :body.
    
      ```clojure
      (def email (mailgun {:sandbox "mail.relay" :service-key "key"}
                          {:from "riemann@trioptimum.com"}))
      ```
    
      If you provide a single map, the mailer will split the mailgun options out
      for you.
    
      ```clojure
      (def email (mailgun {:sandbox "mail.relay"
                           :service-key "foo"
                           :from "riemann@trioptimum.com"}))
      ```
    
      By default, riemann uses (subject events) and (body events) to format emails.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def email (mailgun {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```
    
      This api uses text body by default. If you want to use HTML body, you can set
      a body formatter function returns a map of fields :type and :content.
    
      ```
      (def email (mailgun {} {:body (fn [events]
                                     {:type :html
                                      :content "<h1>HTML Body</h1>"})}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/pipeSourceDoc + Usages
    Sometimes, you want to have a stream split into several paths, then
      recombine those paths after some transformation. Pipe lets you write
      these topologies easily.
    
      We might express a linear stream in Riemann, in which a -> b -> c -> d, as
    
      (a (b (c d)))
    
      With pipe, we write
    
      ```clojure
      (pipe ↧ (a ↧)
              (b ↧)
              (c ↧)
              d)
      ```
    
      The first argument ↧ is a *marker* for points where events should flow down
      into the next stage. A delightful list of marker symbols you might enjoy is
      available at http://www.alanwood.net/unicode/arrows.html.
    
      What makes pipe more powerful than the standard Riemann composition rules is
      that the marker may appear *multiple times* in a stage, and *at any depth in
      the expression*. For instance, we might want to categorize events based on
      their metric, and send all those events into the same throttled email stream.
    
      ```clojure
      (let [throttled-emailer (throttle 100 1 (email "ops@rickenbacker.mil"))]
        (splitp < metric
          0.9 (with :state :critical throttled-emailer)
          0.5 (with :state :warning  throttled-emailer)
              (with :state :ok       throttled-emailer)))
      ```
    
      But with pipe, we can write:
    
      ```clojure
      (pipe - (splitp < metric
                      0.9 (with :state :critical -)
                      0.5 (with :state :warning  -)
                          (with :state :ok       -))
              (throttle 100 1 (email "ops@rickenbacker.mil")))
      ```
    
      So pipe lets us do three things:
    
      0. *Flatten* a deeply nested expression, like Clojure's -> and ->>.
    
      1. *Omit or simplify* the names for each stage, when we care more about the
      *structure* of the streams than giving them full descriptions.
    
      2. Write the stream in the *order in which events flow*.
    
      Pipe rewrites its stages as a let binding in reverse order; binding each
      stage to the placeholder in turn. The placeholder must be a compile-time
      symbol, and obeys the usual let-binding rules about variable shadowing; you
      can rebind the marker lexically within any stage using let, etc. Yep, this is
      a swiss arrow in disguise; ssshhhhhhh. ;-)

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.sns/sns-publisherSourceDoc + Usages
    Returns a publisher, which is a function invoked with a topic ARN or a
      sequence of ARNs and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and publishes a message about them.
    
      ```clojure
      (def sns (sns-publisher))
    
      (changed :state
        (sns "arn:aws:sns:region:id:xerxes" "arn:aws:sns:region:id:shodan"))
      ```
    
      The first argument is a map of AWS credentials:
    
        - :access-key ; required
        - :secret-key ; required
        - :region     ; optional
    
      The :region value is passed to com.amazonaws.regions.RegionUtils/getRegion.
      For a list of region names that you can use, see:
      https://github.com/aws/aws-sdk-java/blob/master/src/main/java/com/amazonaws/regions/Regions.java
    
      (Note: `getRegion` expects the value of the `name` instance variable,
      not the enum type name.)
    
      The second argument is a map of default message options, like :body or
      :subject.
    
      ```clojure
      (def sns (sns-publisher {:access-key "my-access-key"
                               :secret-key "my-secret-key"}
                              {:subject "something is ok"}))
      ```
    
      The third is an optional map specifying async options:
    
        - :async   ; optional true / false (default)
        - :success ; optional callback invoked on success
                   ; e.g. (fn [req res] ...)
        - :error   ; optional callback invoked on error
                   ; e.g. (fn [exception] ...)
                   ; you must specify both :success and :error
                   ; or else, none at all
    
      If you provide a single map, they will be split out for you.
    
      ```clojure
      (def sns (sns-publisher {:access-key "your-access-key"
                               :secret-key "your-secret-key"
                               :subject "something went wrong"
                               :async true}))
      ```
    
      By default, riemann uses (riemann.common/subject events) and
      (riemann.common/body events) to format messages.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def sns (sns-publisher {} {:body (fn [events]
                                          (apply prn-str events))}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.twilio/twilioSourceDoc + Usages
    Returns a messenger, which is a function invoked with a phone number or a sequence
      of phone numbers and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends a message about them.
    
      ```clojure
      (def messenger (twilio))
      (def text (messenger "+15005550006" "+15005550006"))
      ```
    
      This messenger sends sms out via twilio using the twilio http api. When used
      it outputs the http response recieved from twilio.
    
      ```clojure
      (changed :state
        #(info "twilio response" (text %)))
      ```
    
      The first argument is a map of the twilio options :account and :key.
      The second argument is a map of default message option.
    
      ```clojure
      (def text (twilio {:account "id" :service-key "key"}
                        {:from "+15005550006"}))
      ```
    
      Message options can be :
    
      - `:from`                    A twilio phone number
      - `:messaging-service-sid`   The 34 character unique id of the Messaging Service you want to associate with this Message
      - `:media-url`               The URL of the media you wish to send out with the message.
      - `:status-callback`         A URL that Twilio will POST to each time your message status changes to one of the following: queued, failed, sent, delivered, or undelivered
      - `:application-sid`         Twilio will POST MessageSid as well as MessageStatus=sent or MessageStatus=failed to the URL in the MessageStatusCallback property of this Application
      - `:max-price`               The total maximum price up to the fourth decimal (0.0001) in US dollars acceptable for the message to be delivered
      - `:provide-feedback`        Set this value to true if you are sending messages that have a trackable user action and you intend to confirm delivery of the message using the Message Feedback API
    
      Full API documentation can be found here : https://www.twilio.com/docs/api/rest/sending-messages
    
      If you provide a single map, the messenger will split the twilio options out
      for you.
    
      ```clojure
      (def text (twilio {:account "id"
                         :service-key "key"
                         :from "+15005550006"}))
      ```
    
      By default, riemann uses (body events) to format messages.
      You can set your own body formatter functions by including :body in msg-opts.
      These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def text (twilio {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.mailgun/mailgunSourceDoc + Usages
    Returns a mailer, which is a function invoked with an address or a sequence
      of addresses and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and sends email about them.
    
      ```clojure
      (def mailer (mailgun))
      (def email (mailer "xerxes@trioptimum.org" "shodan@trioptimum.org"))
      ```
    
      This mailer sends email out via mailgun using the mailgun http api. When used
      it outputs the http response recieved from mailgun.
    
      ```clojure
      (changed :state
        #(info "mailgun response" (email %)))
      ```
    
      The first argument is a map of the mailgun options :sandbox and :service-key.
      The second argument is a map of default message options, like :from,
      :subject, or :body.
    
      ```clojure
      (def email (mailgun {:sandbox "mail.relay" :service-key "key"}
                          {:from "riemann@trioptimum.com"}))
      ```
    
      If you provide a single map, the mailer will split the mailgun options out
      for you.
    
      ```clojure
      (def email (mailgun {:sandbox "mail.relay"
                           :service-key "foo"
                           :from "riemann@trioptimum.com"}))
      ```
    
      By default, riemann uses (subject events) and (body events) to format emails.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def email (mailgun {} {:body (fn [events]
                                     (apply prn-str events))}))
      ```
    
      This api uses text body by default. If you want to use HTML body, you can set
      a body formatter function returns a map of fields :type and :content.
    
      ```
      (def email (mailgun {} {:body (fn [events]
                                     {:type :html
                                      :content "<h1>HTML Body</h1>"})}))
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/pipeSourceDoc + Usages
    Sometimes, you want to have a stream split into several paths, then
      recombine those paths after some transformation. Pipe lets you write
      these topologies easily.
    
      We might express a linear stream in Riemann, in which a -> b -> c -> d, as
    
      (a (b (c d)))
    
      With pipe, we write
    
      ```clojure
      (pipe ↧ (a ↧)
              (b ↧)
              (c ↧)
              d)
      ```
    
      The first argument ↧ is a *marker* for points where events should flow down
      into the next stage. A delightful list of marker symbols you might enjoy is
      available at http://www.alanwood.net/unicode/arrows.html.
    
      What makes pipe more powerful than the standard Riemann composition rules is
      that the marker may appear *multiple times* in a stage, and *at any depth in
      the expression*. For instance, we might want to categorize events based on
      their metric, and send all those events into the same throttled email stream.
    
      ```clojure
      (let [throttled-emailer (throttle 100 1 (email "ops@rickenbacker.mil"))]
        (splitp < metric
          0.9 (with :state :critical throttled-emailer)
          0.5 (with :state :warning  throttled-emailer)
              (with :state :ok       throttled-emailer)))
      ```
    
      But with pipe, we can write:
    
      ```clojure
      (pipe - (splitp < metric
                      0.9 (with :state :critical -)
                      0.5 (with :state :warning  -)
                          (with :state :ok       -))
              (throttle 100 1 (email "ops@rickenbacker.mil")))
      ```
    
      So pipe lets us do three things:
    
      0. *Flatten* a deeply nested expression, like Clojure's -> and ->>.
    
      1. *Omit or simplify* the names for each stage, when we care more about the
      *structure* of the streams than giving them full descriptions.
    
      2. Write the stream in the *order in which events flow*.
    
      Pipe rewrites its stages as a let binding in reverse order; binding each
      stage to the placeholder in turn. The placeholder must be a compile-time
      symbol, and obeys the usual let-binding rules about variable shadowing; you
      can rebind the marker lexically within any stage using let, etc. Yep, this is
      a swiss arrow in disguise; ssshhhhhhh. ;-)

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.sns/sns-publisherSourceDoc + Usages
    Returns a publisher, which is a function invoked with a topic ARN or a
      sequence of ARNs and returns a stream. That stream is a function which takes a
      single event, or a sequence of events, and publishes a message about them.
    
      ```clojure
      (def sns (sns-publisher))
    
      (changed :state
        (sns "arn:aws:sns:region:id:xerxes" "arn:aws:sns:region:id:shodan"))
      ```
    
      The first argument is a map of AWS credentials:
    
        - :access-key ; required
        - :secret-key ; required
        - :region     ; optional
    
      The :region value is passed to com.amazonaws.regions.RegionUtils/getRegion.
      For a list of region names that you can use, see:
      https://github.com/aws/aws-sdk-java/blob/master/src/main/java/com/amazonaws/regions/Regions.java
    
      (Note: `getRegion` expects the value of the `name` instance variable,
      not the enum type name.)
    
      The second argument is a map of default message options, like :body or
      :subject.
    
      ```clojure
      (def sns (sns-publisher {:access-key "my-access-key"
                               :secret-key "my-secret-key"}
                              {:subject "something is ok"}))
      ```
    
      The third is an optional map specifying async options:
    
        - :async   ; optional true / false (default)
        - :success ; optional callback invoked on success
                   ; e.g. (fn [req res] ...)
        - :error   ; optional callback invoked on error
                   ; e.g. (fn [exception] ...)
                   ; you must specify both :success and :error
                   ; or else, none at all
    
      If you provide a single map, they will be split out for you.
    
      ```clojure
      (def sns (sns-publisher {:access-key "your-access-key"
                               :secret-key "your-secret-key"
                               :subject "something went wrong"
                               :async true}))
      ```
    
      By default, riemann uses (riemann.common/subject events) and
      (riemann.common/body events) to format messages.
      You can set your own subject or body formatter functions by including
      :subject or :body in msg-opts. These formatting functions take a sequence of
      events and return a string.
    
      ```clojure
      (def sns (sns-publisher {} {:body (fn [events]
                                          (apply prn-str events))}))
      ```

    calfpath 0.6.0
    A la carte ring request matching
    calfpath.route/compile-routesSourceDoc + Usages
    Given a collection of route specs, supplement them with required entries and finally return a routes collection.
      Options:
       :uri?            (boolean) true if URI templates should be converted to matchers
       :uri-key         (non-nil) the key to be used to look up the URI template in a spec
       :uri-params-key  (non-nil) the key to put URI params under; if unspecified, params map is merged into request
       :split-params?   (boolean) whether extract URI params under a key in request map by auto-specifying :uri-params-key
       :trailing-slash  (keyword) Trailing-slash action to perform on URIs - :add or :remove - nil (default) has no effect
       :fallback-400?   (boolean) whether to add a fallback route to respond with HTTP status 400 for unmatched URIs
       :show-uris-400?  (boolean) whether to add URI templates in the HTTP 400 response (see :fallback-400?)
       :uri-prefix-400  (string?) the URI prefix to use when showing URI templates in HTTP 400 (see :show-uris-400?)
       :method?         (boolean) true if HTTP methods should be converted to matchers
       :method-key      (non-nil) the key to be used to look up the method key/set in a spec
       :fallback-405?   (boolean) whether to add a fallback route to respond with HTTP status 405 for unmatched methods
       :lift-uri?       (boolean) whether lift URI attributes from mixed specs and move the rest into nested specs

    confucius 0.0.3
    A library for declarative configuration.
    confucius.core/load-configSourceDoc + Usages
    Load configuration data from `sources`. Does deep-merging
       of the data from left to right to form the final configuration
       map. Supports different data sources such as clojure datastructures
       (maps, seqs, vecs), urls or files (currently supports `edn`, `yaml`
       or `json` encoded content), or attempts to coerce strings to urls.
    
       `opts` may be a map with the keys:
    
       :postprocess-fn One arity fn taking the configuration to
                      be post processed. Must return the modified
                      configuration. This may be used e.g. to
                      schema validate the final configuration
                      map.
       :value-readers  By default uses `include-value-reader`,
                      `classpath-value-reader` and
                      `fileref-value-reader`. See
                      `*default-value-readers*`.
    
       `load-config` has support for:
       * variable expansion with deault values `${my-var:default}`
       * extendable value-reader support, by default:
        * including other configuration with `@:`
        * referencing files on the classpath with `cp://...`
        * or referincing files `file://...`
    
    
       A note on syntax and behaviour
    
       Variables will be expanded to values either from other config
       values, java properties, or the native environment. If expansion
       fails the default value is taken. In case no default
       value was given an IllegalStateException is thrown.
       To reference a path in the confguration the variable
       is split at `.` and each segment keywordized, e.g. `${a.b.c}`
       will result in `(get-in cfg [:a :b :c])`. For native env
       lookups `.` is replaced with underscore and the final string
       uppercased. Takes the value as is for lookups in the Java System
       Property.
    
       Referencing configuration with `@:` includes the target at point,
       i.e. the file contents will be inserted at the given key.
    
       Relative file urls will be made absolute by replacing the relative
       part with an absolute path, e.g.
       `file://rel/path` or `file://./rel/path` -> `file:///tmp/rel/path`.
    
    
       Example
    
       Given three configuration files:
    
       ```
       # file on classpath: happy-service.yml
       http-port: 8080
    
       # file on fs (where java is invoked): crazy-service.yml
       http-port: 8081
    
       # file on fs (where java is invoked): config.yml
       base-path: "file://${expanded-from-env:target}"
    
       happy-service: "@:cp://happy-service.yml"
       crazy-service: "@:file://crazy-service.yml"
       ```
    
       Loading `config.yml` will result in the following map:
    
       ```
       {:base-path "file:///projects/confucius/target"
       :happy-service {:http-port 8080}
       :crazy-service {:http-port 8081}}
       ```
    
       where `${expanded-from-env}` will be expanded
       from the environment. Use default value if it
       not found or throws when none was provided.

    bolth 0.1.0
    FIXME: write description
    bolth/run-all-testsSourceDoc + Usages
    runs tests, just like clojure.test/run-all-tests.
       Takes an optional regex to only run matching vars, and an options map.
    
      ## Available options
    
      :show-slow-tests : an boolean (default is false)
    
      tracks individual test runtimes and reports the slowest N tests (where N is specified by the option :slow-test-count, defaults to 10).
      Note that if any tests fail, the slow tests won't be shown (because you should fix the tests before optimizing test runtime).
    
      :slow-test-count : an positive number (default is 10)
    
      the number of slow tests to report (see :show-slow-tests)
    
      :warn-on-slow-test-limit-ms : an positive number (defaults to 1000ms which is 1 second : feedback time is an thing)
    
      prints a warning if the total test runtime is over the number of ms specified by this option. Feedback time is a real thing.
    
      :clear-screen : an boolean (defaults to false)
    
      if set to true, prints (:clear-screen-lines options 50) before running tests, to clear any existing screen state
    
      :clear-screen-lines : an positive integer (defaults to 50)
    
      see :clear-screen
    
      :force-real-stdout : an boolean (defaults to false)
    
      if set as a truthy value, overrides stdout to be System/out. This is useful if you're running in an editor in a tmux split
      with the repl, and triggering test runs via the editor or grenchman - it means the test output will go in the repl, so it'll
      hang around
    
      :flush-interval : an positive integer (defaults to 10)
    
      bolth prints a `.` whilst running tests, for each test run. Many test runners flush stdout after printing each `.`, but this
      can significantly slow down test suites if the suite is large enough or the terminal it's printing to is slow enough.
      Instead, bolth spawns a thread that flushes stdout every (:flush-interval options 10) milliseconds. This gives you timely
      feedback that the suite is still running, whilst not causing performance issues. After the run is finished the thread is
      cleaned up.
    
      :exit-with-error-code : an boolean (defaults to false)
    
      if set to a truthy value, calls (System/exit) after running, with exit code 0 if all the tests passed, or exit code 1 if any tests failed.
    
      :frame-options : an map (defaults to {:frame-limit 10})
    
      options for io.aviso.exception/write-exception. Defaults to just showing 10 lines from exception stacktraces. See (doc io.aviso.exception/write-exception) for full documentation.
    
      ## Returned value
    
      After running (assuming :exit-with-error-code wasn't set),
      run-all-tests returns a value detailing the test run:
    
      {:test-run {:type :summary, :fail 1, :error 0, :pass 1, :test 2},
    
      the return value from clojure.test. Returns counts of passing/failing/etc tests
    
    
      :test-runner-state
      {:results
        [{:vars "(an-failing-test) (bolth_test.clj:7)",
          :contexts "",
          :result
          {:message nil,
          :actual (2),
          :expected 1,
          :diffs ([2 (1 2)]),
          :type :fail,
          :file "bolth_test.clj",
          :line 7},
          :runtime 37586569}]},
    
      iff :show-slow-tests is enabled, will contain a set of test run results.
    
      :runtime 45.505684
    
      the overall time taken for this call, in milliseconds
    
      }

    Constructor for the pipeline controller.
    
    Pipeline controllers are special type of Keechma controllers that handle their commands with pipelines. Pipelines allow you to model a command / action as a series of steps. Pipelines know how to handle promises and they themselves return a promise.
    
    Pipelines allow you to split async actions into distinct steps:
    
    - Pipeline processing
    - Sideffects
    
    If a pipeline processing step returns a promise (for instance from an AJAX request), pipeline will wait until that promise is resolved before proceeding to the next step.
    
    Simple example
    
    ```clojure
    (ns some-namespace
      (:require [keechma.toolbox.pipeline.controller :as pp-controller]
                [keechma.toolbox.pipeline.core :as pp :refer-macros [pipeline!]])
    
    (def some-controller
      (fn [route-params] true) ;; route params function
      {:start (pipeline! [value app-db]
                (pp/commit! (assoc-in app-db [:kv :current-user-status] :loading))
                (load-user-from-server)
                (pp/commit! (->app-db
                               (assoc-in [:kv :current-user-status] :loaded)
                               (assoc-in [:kv :current-user] value))))})
    ```
    
    In the previous example three things happened:
    
    1. We stored current user status as `:loading` in the app-db
    2. We loaded user from the server
    3. We stored the current user status and the current user in the app-db
    
    `value` always holds the returned (or resolved) value from the previous processing step - unless the function returns `nil` in that case, value is bound to the previous value. Also, we had to use the `commit!` sideffect function to mutate the app-db.
    
    `value` and `app-db` arguments are always bound to the current pipeline value and to the current version of app-db. This means that in every processing step, value and app-db point to the results of the previous processing step.`
    
    If we want to handle errors or rejections in pipelines, we can use the `rescue!` block:
    
    ```clojure
    (def some-controller
      (fn [route-params] true) ;; route params function
      {:start (pipeline! [value app-db]
                (pp/commit! (assoc-in app-db [:kv :current-user-status] :loading))
                (load-user-from-server)
                (pp/commit! (->app-db
                               (assoc-in [:kv :current-user-status] :loaded)
                               (assoc-in [:kv :current-user] value)))
                (rescue! [error]
                  (pp/commit! (assoc-in app-db [:kv :current-user-status] :error))})
    ```
    
    Rescue block will catch any errors that happen in the pipeline - including the promises that were rejected. Steps in the rescue block have access to value and app-db arguments.
    
    **Nesting pipelines**
    
    Sometimes you need to run the pipeline only if some condition is true. In that case you can nest pipelines:
    
    ```clojure
    (def some-controller
      (fn [route-params] true) ;; route params function
      {:start (pipeline! [value app-db]
                (when (= value true)
                  (pipeline! [value app-db]
                    (some-api-call)
                    (pp/commit! (mutate-app-db app-db)))))}) 
    ```
    
    **Pipeline sideffects**
    
    Pipelines can have various sideffects:
    
    1. `commit!` - commits the new app-db version in the global app-db atom
    2. `send-command!` - sends command to another controller
    3. `execute!` - executes command in the current controller
    4. `redirect!` - redirects to a different URL
    
    **Exclusive pipelines**
    
    In some cases you want to always run only one pipeline at a time. One example of that behavior is the live search. 
    
    Let's say that you want to implement it as a command that runs on every key press. After the command is ran, it should wait for 500msec before calling the API. If the command is called again in these 500msec, stop the pipeline and run a new one.
    
    Here's how you would implement this feature:
    
    ```clojure
    (def search-controller
      (pp-controller/constructor
       (fn [] true)
       {:search (pp/exclusive
                 (pipeline! [value app-db]
                   (when-not (empty? value)
                     (pipeline! [value app-db]
                       (delay-pipeline 500)
                       (movie-search value)
                       (println "SEARCH RESULTS:" value)))))}))
    ```
      

    
    Registers dataloader controller to the controller map
    
    ```clojure
     (def app
      {:controllers (-> {}
                        (keechma.toolbox.dataloader.controller/register datasources-map edb-schema))})
    ```
    
      `keechma.toolbox.dataloader.controller/register` function expects three arguments:
    
    - controller map
    - datasources map
    - EDB schema
    
    It returns a new version of the controller map with the dataloader controller registered.
    
    **Datasources**
    
    Datasource is an abstraction of any data that is loaded from the "outside" world. It can be an API endpoint, local storage value or any other data that is not present in the application state.
    
    Dataloader allows you to declaratively list your datasources. It then determines when and how the datasources should be loaded. Datasources can be defined as a graph, where datasources can depend on other datasources. This removes any need to manually load data in the correct order. When datasources params or depenedencies change, dataloader will invalidate that datasource and reload it.
    
    Dataloader checks it's datasources on each route change. If the datasource `params` function returns a result different from the previous result, this datasource (and any datasources that depend on it) will be reloaded.
    
    Dataloader can be manually triggered by sending the `:load-data` command to the dataloader controller.
    
    **Example**
    
    ```clojure
    
    (defn promised-datasource
     ([] (promised-datasource nil))
     ([data]
      (fn [params]
        (map (fn [loader-params]
               (p/promise (fn [resolve reject]
                            (let [value (or data (:params loader-params))]
                              (js/setTimeout #(resolve value) 1)))))
             params))))
    
    (def simple-promised-datasource (promised-datasource))
    
    (def simple-datasources
     {:jwt
      {:target [:kv :jwt]
       :loader (promised-datasource)
       :processor (fn [value datasource]
                    (str value "!"))
       :params (fn [prev route _]
                 (or (:jwt route) "JWT"))}
    
      :current-user
      {:target [:kv :user :current]
       :deps   [:jwt]
       :loader simple-promised-datasource
       :params (fn [prev route {:keys [jwt]}]
                 {:jwt jwt
                  :current-user-id 1})}
    
      :users
      {:target [:kv :user :list]
       :deps   [:jwt]
       :loader simple-promised-datasource
       :params (fn [prev route {:keys [jwt]}]
                 {:jwt jwt
                  :users [{:id 1} {:id 2}]})}
    
      :current-user-favorites
      {:target [:kv :favorites :current]
       :deps   [:jwt :current-user]
       :loader simple-promised-datasource
       :params (fn [prev route {:keys [jwt current-user]}]
                 {:jwt jwt
                  :current-user current-user
                  :favorites [{:id 3} {:id 4}]})}})
    ```
    
    A lot of stuff is happening in this example, so let's explain them one by one.
    
    `promised-datasource` function is used as an example loader. The important thing to note here is that loader functions accept an array of requests. This means that you can use this function as an optimization point, a place where you can optimize the requests - remove duplicates or combine them into one request. Loader function should return a list of promises or results (these can be combined). Dataloader will wait for each promise to resolve, and then continue loading the dependent datasources.
    
    Datasources are registered in the map, and the key under which the datasource is registered can be used by the other datasources to depend on it.
    
    Each datasource map can have the following attributes:
    
    - `:target` - where to store the returned data
    - `:params` - function that returns the params needed to load the data
    - `:loader` - function that is used to load the data, this function gets a list of requests
    - `:deps` - list of datasources that the datasource depends on
    - `:processor` - function that processes the result data before it gets stored in the app-db
    
    **`:target` attribute**
    
    Target attribute tells dataloader where it should store the loaded data. It has three different forms:
    
    - general path - `[:kv :user]` - it will be stored under this path in the app-db
    - EntityDB collection path - `[:edb/collection :user/list]` - If the first element of the target vector is `:edb/collection` keyword, the results will be treated as the EntityDB collection and the second element of the vector will be split on `/` to determine where this collection should be stored. If the second element of the target vector looked like `:user/list` the data would be stored in the collection named `:list` for the entity named `:user`.
    - EntityDB named item - `[:edb/named-item :user/current]` - this will store the EntityDB named item, using the same rules like the EntityDB collection target to determine where the item should be stored.
    
    **`:params` attribute**
    
    Params function returns the params needed to load the datasource. It receives three arguments:
    
    - previously loaded value
    - current route
    - datasource dependencies
    
    This function is called to determine the current datasource state. If the returned value is different from the previously returned value, the datasource will be reloaded. Loader function receives the params, and it has to make sense of it. Even if your params fn returns `nil`, loader function will be called. It is loader function's responsobility to decide what the returned params mean.
    
    **`:loader`** attribute:
    
    Loader function is responsible for the data loading. This is where you should place your AJAX request functions. Loader function will receive a vector of requests (one element for each "triggered" datasource). Each request comes from a datasource, and it contains the following attributes:
    
    - `:params` - value returned from the "params" function
    - `:prev` - previously loaded value
    - `:datasource` - key under which the datasource is registered
    - `:app-db` - current app-db state
    - `:target` - path where data will be stored in the app-db
    
    Loader function should return a vector (one item for each request). Values in the returned vector can be either promises or resolved values.
    
    
    **Manually triggering the Dataloader**
    
    In some cases you will want to manually trigger the dataloader without the route change. For instance you might obtain a JWT token as a result of some user's action, and then reload all datasources that depend on it. Dataloader controller can manually trigger the dataloader. You can achieve this by sending the `:load-data` command to the dataloader controller:
    
    ```clojure
    (ns some.namespace
      (:require [keechma.toolbox.dataloader.core :as dataloader]
            [keechma.controller :as controller]))
    
    (defn trigger-dataloader [ctrl]
      (controller/send-command ctrl [dataloader/id-key :load-data])) ;; dataloader controller will be registered under the dataloader/id-key keyword
    ```
    
    This will reload all invalidated datasources.
    
    **Keeping track of dataloader status from a different controller
    
    Sometimes it's valuable to know when the dataloader is done with loading. There are two ways to get this info, and they depend on the flavor of your controller.
    
    If you're using pipelines (and `keechma.toolbox.pipeline.controller`) you can use the built in `keechma.toolbox.dataloader.controller/wait-dataloader-pipeline!` function which will block the pipeline until the dataloader is finished with loading.
    
    ```clojure
    (pipeline! [value app-db]
      (keechma.toolbox.dataloader.controller/wait-dataloader-pipeline!)
      (some-fn)
    ```
    
    In this case `some-fn` will be called after the dataloader is done.
    
    If you're using a normal controller API (where you implement the `handler` function), you can listen for the `:keechma.toolbox.dataloader.controller/status-change` command. This command will be sent with `:pending` or `:loaded` as payload - depending on the dataloader's status.