diff --git a/egison.cabal b/egison.cabal
--- a/egison.cabal
+++ b/egison.cabal
@@ -1,5 +1,5 @@
 Name:                egison
-Version:             3.5.5
+Version:             3.5.6
 Synopsis:            Programming language with non-linear pattern-matching against unfree data
 Description:
   An interpreter for Egison, a **pattern-matching-oriented**, purely functional programming language.
diff --git a/hs-src/Language/Egison/Primitives.hs b/hs-src/Language/Egison/Primitives.hs
--- a/hs-src/Language/Egison/Primitives.hs
+++ b/hs-src/Language/Egison/Primitives.hs
@@ -22,6 +22,7 @@
 
 import qualified Data.Sequence as Sq
 
+import Data.Char (ord, chr)
 import qualified Data.Text as T
 import qualified Data.Text.IO as T
 
@@ -141,6 +142,8 @@
                
              , ("itof", integerToFloat)
              , ("rtof", rationalToFloat)
+             , ("ctoi", charToInteger)
+             , ("itoc", integerToChar)
 
              , ("pack", pack)
              , ("unpack", unpack)
@@ -378,6 +381,18 @@
     Integer i -> return $ Float $ fromInteger i
     Rational r -> return $ Float $ fromRational r
     _ -> throwError $ TypeMismatch "integer of rational number" (Value val)
+
+charToInteger :: PrimitiveFunc
+charToInteger = oneArg $ \val -> do
+  case val of
+    Char c -> return $ Integer $ fromIntegral $ ord c
+    _ -> throwError $ TypeMismatch "character" (Value val)
+
+integerToChar :: PrimitiveFunc
+integerToChar = oneArg $ \val -> do
+  case val of
+    Integer i -> return $ Char $ chr $ fromIntegral i
+    _ -> throwError $ TypeMismatch "character" (Value val)
 
 floatToIntegerOp :: (Double -> Integer) -> PrimitiveFunc
 floatToIntegerOp op = oneArg $ \val -> do
diff --git a/lib/core/number.egi b/lib/core/number.egi
--- a/lib/core/number.egi
+++ b/lib/core/number.egi
@@ -124,9 +124,6 @@
 ;;;
 ;;; Decimal Fractions
 ;;;
-(define $decimal (algebraic-data-matcher {<df integer (list integer)>}))
-(define $decimal' (algebraic-data-matcher {<df' integer (list integer) (list integer)>}))
-
 (define $rtod-helper
   (lambda [$m $n]
     (let {[$q (quotient (* m 10) n)]
@@ -134,12 +131,12 @@
       {[q r] @(rtod-helper r n)})))
 
 (define $rtod
-  (lambda [$x]
+  (lambda [$c $x]
     (let* {[$m (numerator x)]
            [$n (denominator x)]
            [$q (quotient m n)]
            [$r (remainder m n)]}
-      <Df q (map fst (rtod-helper r n))>)))
+      [q (take c (map fst (rtod-helper r n)))])))
 
 (define $rtod'
   (lambda [$x]
@@ -148,17 +145,17 @@
            [$q (quotient m n)]
            [$r (remainder m n)]
            [[$s $c] (find-cycle (rtod-helper r n))]}
-      <Df' q (map fst s) (map fst c)>)))
+      [q (map fst s) (map fst c)])))
 
 (define $show-decimal
-  (lambda [$n $x]
-    (match (rtod x) decimal
-      {[<df $q $sc> (foldl S.append (S.append (show q) ".") (map show (take n sc)))]})))
+  (lambda [$c $x]
+    (match (rtod c x) [integer (list integer)]
+      {[[$q $sc] (foldl S.append (S.append (show q) ".") (map show sc))]})))
 
 (define $show-decimal'
   (lambda [$x]
-    (match (rtod' x) decimal'
-      {[<df' $q $s $c> (foldl S.append "" {(S.append (show q) ".") @(map show s) " " @(map show c) " ..."})]})))
+    (match (rtod' x) [integer (list integer) (list integer)]
+      {[[$q $s $c] (foldl S.append "" {(S.append (show q) ".") @(map show s) " " @(map show c) " ..."})]})))
 
 ;;;
 ;;; Continued Fraction
diff --git a/lib/core/string.egi b/lib/core/string.egi
--- a/lib/core/string.egi
+++ b/lib/core/string.egi
@@ -42,6 +42,10 @@
   (lambda [$xs]
     (eq? xs "")))
 
+(define $S.cons
+  (lambda [$x $xs]
+    (append-string (pack {x}) xs)))
+
 (define $S.car
   (lambda [$xs]
     (match xs string