CrossClj
split
RECENT

    Search for split in the documentation of all artifacts.

    Vars

    1. org.clojure/clojure clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    2. org.clojure/clojurescript clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    3. org.clojure/core.async cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    4. org.clojure/core.async clojure.core.async/split Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    5. org.clojure/test.check clojure.test.check.random/split Src Docs Usages
      Returns two new RNGs [rng1 rng2], which should generate
        sufficiently independent random data.
      
        Note: to maintain independence you should not call more than one
        function in the IRandom protocol with the same argument
    6. org.clojure/core.match clojure.core.match.protocols/split Src Docs Usages
    7. org.clojure/clojure-contrib clojure.contrib.str-utils2/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits.
    8. org.clojure/clojure-contrib clojure.contrib.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits.
    9. camel-snake-kebab camel-snake-kebab.internals.string-separator/split Src Docs Usages
      : StringSeparator -> String -> NonEmptySeq[String]
    10. pathetic pathetic.core/split Src Docs Usages
    11. pathetic pathetic.core/split (cljs) Src Docs Usages
    12. lein-ancient ancient.version-clj.v0v1v2.version-clj.split/split Src Docs Usages
    13. lein-ancient ancient.version-clj.v0v1v2.version-clj.split/split (cljs) Src Docs Usages
    14. fs fs.core/split Src Docs Usages
      Split path to components.
    15. cider/cider-nrepl cider.inlined-deps.cljfmt.v0v5v7.rewrite-cljs.v0v4v3.rewrite-clj.paredit/split (cljs) Src Docs Usages
      Split current s-sexpression in two at given node `zloc`
      
        -  `[1 2 |3 4 5] => [1 2 3] [4 5]`
    16. lamina lamina.core.channel/split Src Docs Usages
    17. lamina lamina.core.graph.node/split? Src Docs Usages
    18. lamina lamina.core/split Src Docs 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)))
    19. io.replikativ/hasch cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    20. io.replikativ/hasch clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    21. secretary clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    22. version-clj version-clj.split/split Src Docs Usages
    23. version-clj version-clj.split/split (cljs) Src Docs Usages
    24. org.clojure/data.finger-tree clojure.data.finger-tree/split Src Docs Usages
      Return [pre m post] where pre and post are trees
    25. rewrite-cljs rewrite-clj.paredit/split (cljs) Src Docs Usages
      Split current s-sexpression in two at given node `zloc`
      
        -  `[1 2 |3 4 5] => [1 2 3] [4 5]`
    26. zcaudate/hara.string.path hara.string.path/split Src Docs 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"]
    27. refactor-nrepl mranderson047.fs.v1v4v6.me.raynes.fs/split Src Docs Usages
      Split path to components.
    28. refactor-nrepl mranderson047.version-clj.v0v1v2.version-clj.split/split Src Docs Usages
    29. refactor-nrepl mranderson047.version-clj.v0v1v2.version-clj.split/split (cljs) Src Docs Usages
    30. io.pedestal/pedestal.route io.pedestal.http.route.prefix-tree/split Src Docs 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.
    31. lambdacd clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    32. lambdacd pathetic.core/split (cljs) Src Docs Usages
    33. lambdacd cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    34. org.clojure/data.avl clojure.data.avl/split Src Docs Usages
    35. org.clojure/data.avl clojure.data.avl/split (cljs) Src Docs Usages
    36. com.7theta/utilis utilis.string/split Src Docs Usages
      Splits a string 's' on the regular expression 're'. Optionally
        :quote-chars can be provided to avoid splitting the string within
        quoted sections.
    37. co.paralleluniverse/pulsar co.paralleluniverse.pulsar.async/split Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
         channels, the first of which will contain the values for which the
         predicate returned true, the second those for which it returned
         false.
      
         The out channels will be unbuffered by default, or two buf-or-ns can
         be supplied. The channels will close after the source channel has
         closed.
    38. im.chit/hara.ova hara.ova/split Src Docs 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])
    39. thinktopic/cortex cortex.nn.layers/split Src Docs Usages
    40. thinktopic/cortex cortex.verify.nn.layers/split Src Docs Usages
    41. io.replikativ/superv.async clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    42. io.replikativ/superv.async cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    43. zcaudate/lucid.legacy lucid.legacy.match.protocols/split Src Docs Usages
    44. rethinkdb rethinkdb.query/split Src Docs 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```.)
    45. dynadoc clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    46. dynadoc cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    47. yetibot.core yetibot.core.commands.collections/split Src Docs Usages
      split <pattern> <string> # split string with <pattern>
    48. thedavidmeister/hoplon-elem-lib clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    49. thedavidmeister/hoplon-elem-lib camel-snake-kebab.internals.string-separator/split Src Docs Usages
      : StringSeparator -> String -> NonEmptySeq[String]
    50. zcaudate/hara.test hara.test.form/split Src Docs 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}])
    51. superstring superstring.core/split (cljs) Src Docs Usages
    52. ez-form cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    53. ez-form clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    54. thomasa/mranderson mranderson048.fs.v1v4v6.me.raynes.fs/split Src Docs Usages
      Split path to components.
    55. aot-match clojure.core.match/split Src Docs Usages
    56. onaio/milia cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    57. onaio/milia clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    58. com.bhauman/rebel-readline rebel-readline.jline-api.attributed-string/split Src Docs Usages
    59. re-view-hiccup clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    60. com.ryanmcg/stefon stefon.asset/split Src Docs Usages
    61. riemann riemann.streams/split Src Docs 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))
        ```
    62. riemann riemann.streams/split* Src Docs 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))
        ```
    63. pretty-spec clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    64. pretty-spec cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    65. aerial.fs aerial.fs/split Src Docs Usages
      Split path to componenets.
      	(split "a/b/c") -> ("a" "b" "c")
    66. racehub/om-bootstrap om-bootstrap.button/split (cljs) Src Docs Usages
      Inputs: [opts :- SplitButton & children]
    67. com.degel/iron clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    68. zcaudate/hara.concurrent.ova hara.concurrent.ova/split Src Docs 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]
    69. org.intermine/imcljs cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    70. org.intermine/imcljs clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    71. catnip clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    72. re-view-routing clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    73. onaio/hatti clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    74. onaio/hatti cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    75. ff-om-draggable cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    76. ff-om-draggable clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    77. galdolber/clojure-objc clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    78. district0x/cljs-ipfs-native camel-snake-kebab.internals.string-separator/split Src Docs Usages
      : StringSeparator -> String -> NonEmptySeq[String]
    79. district0x/cljs-ipfs-native camel-snake-kebab.internals.misc/split Src Docs Usages
    80. district0x/cljs-ipfs-native cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    81. district0x/cljs-ipfs-native clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    82. cljam cljam.algo.sorter/split* Src Docs Usages
      Splits SAM/BAM files with appropriate reader/writer functions.
    83. cljam cljam.algo.sorter/split** Src Docs Usages
      Splits SAM/BAM file into multiple files each containing alignments up to chunk-size.
        name-fn must be a function taking a int value i and returning a path string for i-th output.
        read-fn must produce a sequence of alignments and write-fn must consume the splitted sequence.
    84. autodoc/autodoc-collect autodoc-collect.load-files/split Src Docs Usages
    85. jah524/prism clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    86. spootnik/net net.transform.split/split Src Docs Usages
      Facility function to create a splitter which yields a single
         collection of ByteBuf instances.
    87. hswick/jutsu cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    88. hswick/jutsu clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    89. io.replikativ/hitchhiker-tree clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    90. skm-ice-utils clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    91. cav/cljcav cav.core/split Src Docs Usages
      Split a coll into n pieces. The inverse of the interleave function.
    92. cav/cljcav cav.core/split (cljs) Src Docs Usages
      Split a coll into n pieces. The inverse of the interleave function.
    93. receipt clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    94. com.vitalreactor/derive cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    95. com.vitalreactor/derive clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    96. andare cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    97. andare clojure.core.async/split Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    98. aerial.utils aerial.utils.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    99. zcaudate/lucid.distribute lucid.distribute.split/split Src Docs Usages
      splits up current project to put in the interim directory
                
         (split (project/project))
         ;;=> look in `target/interim` for changes
         
    100. buddy-pkcs15-sha1 clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    101. civs civs.logic.tribe-choices/split Src Docs Usages
    102. com.vitalreactor/nativestore clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    103. narrator narrator.core/split Src Docs Usages
    104. lein-repack leiningen.repack.split/split Src Docs Usages
    105. lein-repack leiningen.repack/split Src Docs Usages
    106. reagent-slider cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    107. reagent-slider clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    108. z-com/xd-table cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    109. z-com/xd-table clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    110. serovers serovers.core/split Src Docs Usages
    111. fsmviz clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    112. foam clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    113. foam cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    114. yfinance clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    115. mathdoc2 mathdoc2.client.slide.fragment/split (cljs) Src Docs Usages
    116. lsenta/budb cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    117. lsenta/budb clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    118. pdfsplit pdfsplit.split/split Src Docs 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.
    119. district0x/re-frame-ipfs-fx camel-snake-kebab.internals.string-separator/split Src Docs Usages
      : StringSeparator -> String -> NonEmptySeq[String]
    120. district0x/re-frame-ipfs-fx camel-snake-kebab.internals.misc/split Src Docs Usages
    121. district0x/re-frame-ipfs-fx cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    122. district0x/re-frame-ipfs-fx clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    123. org.kowboy/spigot-repl clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    124. clj-thamil clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    125. dali clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    126. live-components clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    127. carry clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    128. aramis clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    129. aramis cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    130. com.walmartlabs/riemann-jmx-clj clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    131. macroexpanse/lemonade cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    132. macroexpanse/lemonade clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    133. me.arrdem/clojarr clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    134. mx.interware/caudal mx.interware.arp.streams.stateless/split Src Docs Usages
        Streamer function that filters events by multiple conditionals  
        > **Arguments**:  
          *exprs*: Conditionals to filter  
        
    135. vee cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    136. vee clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    137. ventas cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    138. ventas pathetic.core/split (cljs) Src Docs Usages
    139. ventas clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    140. monte.server clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    141. skm-ice-gui clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    142. clj-cav cav.core/split Src Docs Usages
      Split a coll into n pieces. The inverse of the interleave function.
    143. clj-cav cav.core/split (cljs) Src Docs Usages
      Split a coll into n pieces. The inverse of the interleave function.
    144. org.skummet/clojure-android clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    145. devth/timbre-datomic-handler clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    146. anki-cljs clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    147. lean-map clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    148. rejax clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    149. chantrix chantrix.async/split Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    150. clodash clodash.string/split Src Docs Usages
    151. cleancr clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    152. cleancr clojure.contrib.str-utils2/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits.
    153. cleancr clojure.contrib.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits.
    154. com.jeditoolkit/node node.path/split (cljs) Src Docs Usages
      Returns the vector of path elements that constitute path
      
          (node.path/split "/Users/Clojure") ;=> ["" "Users" "Clojure"]
    155. nio2 nio2.core/split Src Docs Usages
    156. hellonico-alchemy clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    157. circleci/circle-util circle-util.fs/split Src Docs Usages
      fs/split without using reflection
    158. torus-pong clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    159. torus-pong clojure.core.async/split Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    160. torus-pong clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    161. gov.nasa.earthdata/cmr-client clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    162. gov.nasa.earthdata/cmr-client cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    163. ccw/clojure-ccw clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    164. cljs-audiocapture cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    165. zsau/id3 id3.common/split Src Docs Usages
    166. flyer clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    167. thinkdb rethinkdb.query/split Src Docs 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```.)
    168. reepl clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    169. whodidthis/om-image-grid cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    170. whodidthis/om-image-grid clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    171. revise bitemyapp.revise.utils.case/split Src Docs Usages
    172. fif clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    173. monsato cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    174. fqcss clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    175. paredit-cm clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    176. react-bootstrap-wrapper clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    177. im.chit/hara.keyword hara.string.path/split Src Docs 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]
        
    178. org.gershwinlang/gershwin clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    179. com.greenyouse/pldb-cache cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    180. cloth cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    181. cloth clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    182. cloth cuerdas.core/split Src Docs Usages
      Splits a string on a separator a limited
        number of times. The separator can be a string
        or Pattern (clj) / RegExp (cljs) instance.
    183. cloth pathetic.core/split (cljs) Src Docs Usages
    184. gyptis cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    185. gyptis clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    186. synfnetic/erzeugen clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    187. synfnetic/erzeugen cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    188. lupapiste/lein-hgnotes leiningen.hgnotes/split Src Docs Usages
    189. ags799/boot-docker clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    190. qualityclj cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    191. qualityclj clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    192. z-com/elastic-input cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    193. z-com/elastic-input clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    194. ona-viewer cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    195. ona-viewer clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    196. com.yegortimoshenko/core.storage cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    197. com.yegortimoshenko/core.storage clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    198. bocko-android clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    199. bocko-android cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    200. cljs-css-modules clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    201. com.iterinc/edn-xhr clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    202. com.iterinc/edn-xhr cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    203. tyan-a-bumfit clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    204. z-com/linetree cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    205. z-com/linetree clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    206. cljs-ratios clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    207. org.ajoberstar/clj-dotfiles clojure.string/split Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    208. co.zensight/reagent-quill clojure.string/split (cljs) Src Docs Usages
      Splits string on a regular expression.  Optional argument limit is
        the maximum number of splits. Not lazy. Returns vector of the splits.
    209. co.zensight/reagent-quill cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.
    210. pchalasani/cascadog cascadog.core-test/split Src Docs Usages
    211. pchalasani/cascadog cascadog.new-test/split Src Docs Usages
    212. cljs-bach cljs.core.async/split (cljs) Src Docs Usages
      Takes a predicate and a source channel and returns a vector of two
        channels, the first of which will contain the values for which the
        predicate returned true, the second those for which it returned
        false.
      
        The out channels will be unbuffered by default, or two buf-or-ns can
        be supplied. The channels will close after the source channel has
        closed.

    Namespaces

    Projects

  • No projects found.