Splitting

Splitting strings into substrings is realized by these 3 API functions:

• all-prefixes,
• all-suffixes
• all-subs.

Getting all prefixes

To get all possible prefixes of the given string you can call all-prefixes function from the API. In its basic form, it takes one argument which should be a string and returns a lazy sequence of strings, including the original string in the last position:

(require '[smangler.api :as sa])

(sa/all-prefixes       "")  ; => nil
(sa/all-prefixes "abcdef")  ; => ("a" "ab" "abc" "abcd" "abcde" "abcdef")
(sa/all-prefixes      "a")  ; => ("a")

Coercion to strings

You can pass other types of arguments and they will be coerced to strings. Single characters and numbers are supported, and so are collections of strings, characters and numbers:

(require '[smangler.api :as sa])

(sa/all-prefixes        12345)  ; => ("1" "12" "123" "1234" "12345")
(sa/all-prefixes           \a)  ; => ("a")
(sa/all-prefixes      [0 1 2])  ; => ("0" "01" "012")
(sa/all-prefixes   [\a \b \c])  ; => ("a" "ab" "abc")
(sa/all-prefixes ["abc" "de"])  ; => ("a" "ab" "abc" "abcd" "abcde")

Custom splitter

Optionally, you can call all-prefixes with 2 arguments passed. In this scenario the first argument should be a function which takes a single character and returns a character, false or nil:

(fn [character]
  (and (some-lookup character) character)

The function is used to partition the string. As a result the prefixes will not be generated for all characters but for those substrings which are the effect of splitting the string each time the splitter returns a new value.

(require '[smangler.api :as sa])

(sa/all-prefixes #(and (= \a %) %)
                 "abcdef")  ; => ("a" "abcdef")

Sets as splitters

It is common to use sets for partitioning the string. This is possible because in Clojure sets implement function interface which allows us to perform quick lookup:

(require '[smangler.api :as sa])

(sa/all-prefixes #{\a \b} "abcdef")  ; => ("a" "ab" "abcdef")
(sa/all-prefixes #{\a}    "abcdef")  ; => ("a" abcdef")

Coercion to splitter

You can pass other types of arguments and they will be coerced to splitters. Single characters, strings and numbers are supported, and so are collections of strings, characters and numbers:

(require '[smangler.api :as sa])

(sa/all-prefixes \a        "abcde")  ; => ("a" "abcde")
(sa/all-prefixes 1         "abcde")  ; => ("abcde")
(sa/all-prefixes 12      "12abcde")  ; => ("1" "12" "12abcde")
(sa/all-prefixes [1 2]   "12abcde")  ; => ("1" "12" "12abcde")
(sa/all-prefixes [\a \b]   "abcde")  ; => ("a" "ab" "abcde")
(sa/all-prefixes "ab"      "abcde")  ; => ("a" "ab" "abcde")

Getting all suffixes

Getting all suffixes is possible with all-suffixes. It takes the same arguments and returns the same kind of values as all-prefixes but (as the name stands for) generates all possible suffixes for the given string:

(require '[smangler.api :as sa])

(sa/all-suffixes                "")  ; => nil
(sa/all-suffixes          "abcdef")  ; => ("abcdef" "bcdef" "cdef" "def" "ef" "f")
(sa/all-suffixes               "a")  ; => ("a")

(sa/all-suffixes             12345)  ; => ("12345" "2345" "345" "45" "5")
(sa/all-suffixes                \a)  ; => ("a")
(sa/all-suffixes           [0 1 2])  ; => ("012" "12" "2")
(sa/all-suffixes        [\a \b \c])  ; => ("abc" "bc" "c")
(sa/all-suffixes      ["abc" "de"])  ; => ("abcde" "bcde" "cde" "de" "e")

(sa/all-suffixes  #(and (= \a %) %)
                    "abcdef")        ; => ("abcdef" "bcdef")

(sa/all-suffixes #{\a \b} "abcdef")  ; => ("abcdef" "bcdef" "cdef")
(sa/all-suffixes #{\a}    "abcdef")  ; => ("abcdef" "bcdef")

(sa/all-suffixes \a        "abcde")  ; => ("abcde" "bcde")
(sa/all-suffixes 1         "abcde")  ; => ("abcde")
(sa/all-suffixes 12      "12abcde")  ; => ("12abcde" "2abcde" "abcde")
(sa/all-suffixes [1 2]   "12abcde")  ; => ("12abcde" "2abcde" "abcde")
(sa/all-suffixes [\a \b]   "abcde")  ; => ("abcde" "bcde" "cde")
(sa/all-suffixes "ab"      "abcde")  ; => ("abcde" "bcde" "cde")

Getting all substrings

You can get all possible substrings of a string by calling all-subs from smangler.api. It works similarly to all-prefixes and all-suffixes but returns all prefixes, infixes and suffixes, including the original string:

(require '[smangler.api :as sa])

(sa/all-subs                "")  ; => nil
(sa/all-subs             "abc")  ; => ("a" "ab" "b" "abc" "bc" "c")
(sa/all-subs               "a")  ; => ("a")

(sa/all-subs               123)  ; => ("1" "12" "2" "123" "23" "3")
(sa/all-subs                \a)  ; => ("a")
(sa/all-subs           [0 1 2])  ; => ("0" "01" "1" "012" "12" "2")
(sa/all-subs        [\a \b \c])  ; => ("a" "ab" "b" "abc" "bc" "c")
(sa/all-subs        ["ab" "c"])  ; => ("a" "ab" "b" "abc" "bc" "c")

(sa/all-subs  #(and (= \a %) %)
              "abc")             ; => ("a" "abc" "bc")

(sa/all-subs #{\a \b}    "abc")  ; => ("a" "ab" "b" "abc" "bc" "c")
(sa/all-subs #{\a}       "abc")  ; => ("a" "abc" "bc")

(sa/all-subs \a          "abc")  ; => ("a" "abc" "bc")
(sa/all-subs 1           "abc")  ; => ("abc")
(sa/all-subs 12          "12c")  ; => ("1" "12" "2" "12c" "2c" "c")
(sa/all-subs [1 2]       "12c")  ; => ("1" "12" "2" "12c" "2c" "c")
(sa/all-subs [\a \b]     "abc")  ; => ("a" "ab" "b" "abc" "bc" "c")
(sa/all-subs "ab"        "abc")  ; => ("a" "ab" "b" "abc" "bc" "c")

Low-level splitting

Certain applications may require more efficient and/or more strict splitting functions. It is particularly not recommended but there is smangler.core namespace which contains splitting operations which are a bit faster than those in API. They require certain argument types and no coercion is performed:

• all-prefixes,
• all-suffixes
• all-subs.

(require '[smangler.core :as c])

(c/all-prefixes          nil)  ; => nil
(c/all-prefixes           "")  ; => nil
(c/all-prefixes        "abc")  ; => ("a" "ab" "abc")
(c/all-prefixes  #{\a} "abc")  ; => ("a" "abc")

(c/all-suffixes          nil)  ; => nil
(c/all-suffixes           "")  ; => nil
(c/all-suffixes        "abc")  ; => ("abc" "bc" "c")
(c/all-suffixes  #{\a} "abc")  ; => ("abc" "bc")

(c/all-subs              nil)  ; => nil
(c/all-subs               "")  ; => nil
(c/all-subs            "abc")  ; => ("a" "ab" "b" "abc" "bc" "c")
(c/all-subs      #{\a} "abc")  ; => ("a" "abc" "bc")