(assert "string's value pattern"
  (match "abc" string
    {[,"abc" #t]
     [_ #f]}))

(assert "string's nil - case 1"
  (match "" string
    {[<nil> #t]
     [_ #f]}))

(assert "string's nil - case 2"
  (match "abc" string
    {[<nil> #f]
     [_ #t]}))

(assert-equal "string's cons"
  (match-all "abc" string
    [<cons $x $xs> [x xs]])
  {[c#a "bc"]})

(assert-equal "string's join"
  (match-all "abc" string
    [<join $xs $ys> [xs ys]])
  {["" "abc"] ["a" "bc"]
   ["ab" "c"] ["abc" ""]})

;;;
;;; String as collection
;;;
(assert-equal "S.empty? - case 1"
  (S.empty? "")
  #t)

(assert-equal "S.empty? - case 2"
  (S.empty? "Egison")
  #f)

(assert-equal "S.car"
  (S.car "Egison")
  c#E)

(assert-equal "S.cdr"
  (S.cdr "Egison")
  "gison")

(assert-equal "S.rac"
  (S.rac "Egison")
  c#n)

(assert-equal "S.map"
  (S.map id "Egison")
  "Egison")

(assert-equal "S.length"
  (S.length "Egison")
  6)

(assert-equal "S.split"
  (S.split "," "Lisp,Haskell,Egison")
  {"Lisp" "Haskell" "Egison"})

(assert-equal "S.append"
  (S.append "Egi" "son")
  "Egison")

(assert-equal "S.concat"
  (S.concat {"Egi" "son"})
  "Egison")

(assert-equal "S.intercalate"
  (S.intercalate "," {"Lisp" "Haskell" "Egison"})
  "Lisp,Haskell,Egison")

;;
;; Characters
;;
(assert-equal "C.between"
  (C.between c#a c#c)
  {c#a c#b c#c})

(assert-equal "C.between?"
  (C.between? c#a c#c c#b)
  #t)

(assert-equal "alphabet?"
  (alphabet? c#a)
  #t)

(assert-equal "alphabets?"
  (alphabets? "Egison")
  #t)

(assert-equal "upper-case"
  (upper-case c#e)
  c#E)

(assert-equal "lower-case"
  (lower-case c#E)
  c#e)