String Manipulation in Clojure

;; "a" + "b"
(defn s-add
  [& strings]
  (if (empty? strings)
    ""
    (apply str strings)))
;; => #'user/s-add
(s-add "a" "b")
;; => ab

;; "a" * 10
;; https://stackoverflow.com/questions/5433691/how-to-repeat-string-n-times-in-idiomatic-clojure-way
(defn s-multiply
  [s cnt]
  (apply str (repeat cnt s)))
;; => #'user/s-multiply

(s-multiply "hello" 3)
;; => hellohellohello

(defn s-format
  [& args]                              ; why [:as args] not work???
  (apply format args))
;; => #'user/s-format

(s-format "Hello there, %s" "bob")
;; => Hello there, bob
(s-format "1 + 1 = %d" (+ 1 1))
;; => 1 + 1 = 2

(defn s-join
  ([strings]
   (s-join strings " "))
  ([strings sep]
   (reduce (fn
             ([] "")                     ; for a empty list of strings
             ([a b] (str a sep b)))
           strings)))
;; => #'user/s-join

(s-join ["a" "b" "c"])
;; => a b c
(s-join ["a" "b" "c"] ", ")
;; => a, b, c
(s-join [])
;; =>

(defn s-len
  [s]
  (count s))
;; => #'user/s-len

(s-len "hello")
;; => 5

(defn s-count-char
  "Count the number of the specified `char` in `str`"
  [str char]
  (reduce #(if (= char %2)
             (+ %1 1)
             %1)
          0 str))
;; => #'user/s-count-char

(s-count-char "hello world" \o)
;; => 2
(s-count-char "hello world" \x)
;; => 0
(s-count-char "" \o)
;; => 0

(defn s-endswith?
  ;; or based on clojure.string/ends-with?
  ([s suffix]
   (s-endswith? s suffix 0 (count s)))
  ([s suffix start end]
   "boundaries are: [start, end)"
   (let [start (min start (- (count s) 1))
         end (min end (count s))]
     ;; (println start end)
     (= suffix (subs s
                     (max start (- end (count suffix)))
                     end)))))
;; => #'user/s-endswith?

(s-endswith? "abc" "bc")
;; => true

(defn s-isalpha
  [s]
  (if (empty? s)
    false
    (reduce #(if (not %1)
               false
               (or (<= (int \a) (int %2) (int \z))
                   (<= (int \A) (int %2) (int \Z))))
            true
            s)))
;; => #'user/s-isalpha

(s-isalpha "")
;; => false
(s-isalpha "abcABC")
;; => true
(s-isalpha "abcABC11")
;; => false

(defn s-find
  ([s sub-str]
   (s-find s sub-str 0 (count s)))

  ([s sub-str start end]
   (let [pos (clojure.string/index-of s
                                      sub-str
                                      start)]
     (if (and pos
              (<= (+ pos (count sub-str)) end))
       pos
       -1))))
;; => #'user/s-find

(s-find "abc" "a")
;; => 0
(s-find "abc" "bc")
;; => 1

(defn s-replace
  [s match replacement]
  (clojure.string/replace s match replacement))
;; => #'user/s-replace

;; by char/char
(s-replace "abc" \a \1)
;; => 1bc
;; by string/string
(s-replace "abc" "a" "1")
;; => 1bc
;; by pattern/string
(s-replace "abc" #"[a-z]" "1")
;; => 111
;; by pattern/function
(s-replace "abc" #"[a-z]" #(clojure.string/upper-case %1))
;; => ABC

(defn s-center
  [s width fillchar]
  (let [len (count s)]
    (if (<= width len)
      s
      (let [llen (int (/ (- width len) 2))
            rlen (- width len llen)]
        (str (clojure.string/join (repeat llen fillchar))
             s
             (clojure.string/join (repeat rlen fillchar)))))))
;; => #'user/s-center

(s-center "hello" 10 \x)
;; => xxhelloxxx

(defn s-expandtabs
  ([s]
   (s-expandtabs s 8))
  ([s tabsize]
   (second
    (reduce (fn [state char]
              (if (not= \tab char)
                [(+ 1 (first state)) (str (second state) char)]
                (let [cur-index (first state)
                      next-index (+ cur-index (- tabsize (rem cur-index tabsize)))
                      nspaces (- next-index cur-index)]
                  [next-index (str (second state)
                                   (clojure.string/join (repeat nspaces \space)))])))
            [0 ""]
            s))))
;; => #'user/s-expandtabs

(s-expandtabs "\ta")
;; =>         a
(s-expandtabs "a\tb" 2)
;; => a b
(s-expandtabs "a\t\tb" 2)
;; => a   b
(count (s-expandtabs "a\tb" 2))
;; => 3
(count (s-expandtabs "a\t\tb" 2))
;; => 5

;; in a idiomatic way
(defn title-case-idiomatic
  [str]
  (clojure.string/join " "
                       (map #(clojure.string/capitalize %)
                            (clojure.string/split str #" +"))))
;; => #'user/title-case-idiomatic

(title-case-idiomatic " hello world ")
;; =>  Hello World

;; a.upper()
(defn s-upper
  [str]
  (clojure.string/upper-case str))
;; => #'user/s-upper

(s-upper "hello")
;; => HELLO

(defn s-lower
  [str]
  (clojure.string/lower-case str))
;; => #'user/s-lower

(s-lower "ABc")
;; => abc

(defn s-capitalize [str]
  (clojure.string/capitalize str))
;; => #'user/s-capitalize

(s-capitalize "abc DEf")
;; => Abc def

(defn s-lstrip
  [str]
  (clojure.string/triml str))
;; => #'user/s-lstrip

(s-lstrip "  cde .")
;; => cde .

(defn s-rstrip
  [str]
  (clojure.string/trimr str))
;; => #'user/s-rstrip

(s-rstrip "  cde ")
;; =>   cde

(defn s-strip
  [str]
  (clojure.string/trim str))
;; => #'user/s-strip

(s-strip "  cde ")
;; => cde