Carp/core/String.carp

(defmodule String

  (register =          (Fn [&String &String] Bool))
  (register /=         (Fn [&String &String] Bool))
  (register append     (Fn [String String] String)) ;; TODO: should take a &String as its second argument?
  (register delete     (Fn [String] ()))
  (register copy       (Fn [&String] String))
  (register count      (Fn [&String] Int))
  (register duplicate  (Fn [&String] String))
  (register cstr       (Fn [&String] (Ptr Char)))
  (register str        (Fn [&String] String))
  (register chars      (Fn [&String] (Array Char)))
  (register from-chars (Fn [(Array Char)] String))
  (register head (λ [(Ref String)] Char))
  (register tail (λ [(Ref String)] String))

  (defn repeat [n inpt]
    (let [str ""]
      (do
        (for [i 0 n]
          (set! &str &(append @str @inpt)))
        @str)))

  ;; A temporary version of this function, until we have some nicer way to write it
  (defn split-by [s separators]
    (let [len (count &s)
          result (the (Array String) [])
          cs (chars &s)
          word @""]
      (do
        (for [i 0 len]
          (let [c (Array.nth &cs i)]
            (do
              (if (Int.< 0 (Array.element-count &(the (Array Char) @&separators) @c))
                (if (= 0 (String.count &word))
                  () ;; no word
                  (do (set! &result (Array.push-back @&result @&word))
                      (set! &word @"")))
                (set! &word (append @&word (from-chars [@c])))))))
        ;; Some sweet code duplication for the final word:
        (if (= 0 (String.count &word))
          ()
          (do (set! &result (Array.push-back @&result @&word))
              (set! &word @"")))
        result)))

  (defn words [s]
    (split-by s [\space \tab]))

  (defn lines [s]
    (split-by s [\newline]))
  )

  (defn pad-left [len pad s]
    (let [x (Int.max 0 (Int.- len (String.count s)))]
      (append (from-chars (Array.repeat x pad)) s)))

  (defn pad-right [len pad s]
    (let [x (Int.max 0 (Int.- len (String.count s)))]
      (append s (from-chars (Array.repeat x pad)))))

  (defn empty? [s]
    (Int.= (count s) 0))
)


(defdynamic string-join- [strs]
  (if (= (count strs) 0)
    (String.copy "")
    (list 'String.append (car strs) (string-join- (cdr strs)))))

(defmacro string-join [:rest strs]
  (string-join- strs))