(defcc <number>
   {(list number) ==> number}
   <minus> <number> := (- 0 <number>);
   <plus> <number> := <number>;
   <e-number>;
   <float>;
   <integer>;)

(defcc <minus>
  {(list number) ==> symbol}
  45 := skip;)   

(defcc <plus>
    {(list number) ==> symbol}
    43 := skip;)

(defcc <integer>
   {(list number) ==> number}
    <digits> := (compute-integer  <digits>); )

(defcc <digits>
   {(list number) ==> (list number)}
  <digit> <digits> := [<digit> | <digits>];
   <digit> := [<digit>];)

(defcc <digit>
  {(list number) ==> number}
  Byte := (byte->digit Byte)  where (digit*? Byte);)

(define digit*?
  {number --> boolean}
  Byte -> (and (>= Byte 48) (<= Byte 57)))   

(define byte->digit  
   {number --> number}
    Byte -> (- Byte 48))   

(define compute-integer
  {(list number) --> number}
  Digits -> (compute-integer-h (reverse Digits) 0))

(define compute-integer-h
    {(list number) --> number --> number}
    [] _ -> 0
    [Digit | Digits] Expt -> (+ (* (expt* 10 Expt) Digit) 
                                (compute-integer-h Digits (+ Expt 1))))  

(define expt*
    {number --> number --> number}
    _ 0       -> 1
    Base Expt -> (* Base (expt*  Base (- Expt 1)))  where (> Expt 0)
    Base Expt -> (/ (expt* Base (+ Expt 1)) Base))

(defcc <float>
   {(list number) ==> number}
   <integer> <stop> <fraction> := (+ <integer> <fraction>);)
   
(defcc <stop>
  {(list number) ==> symbol}
    46 := skip;)         

(defcc <fraction>
  {(list number) ==> number}
  <digits> := (compute-fraction <digits>);)

(define compute-fraction
  {(list number) --> number}
  Digits -> (compute-fraction-h Digits -1))

(define compute-fraction-h
  {(list number) --> number --> number}
   [] _ -> 0
   [Digit | Digits] Expt -> (+ (* (expt* 10 Expt) Digit) 
                               (compute-fraction-h Digits (- Expt 1))))   

(defcc <e-number>
   {(list number) ==> number}
  <float> <lowE> <log10>     := (compute-E <float> <log10>);
   <integer> <lowE> <log10>  := (compute-E <integer> <log10>);)

(defcc <log10>
   {(list number) ==> number}
   <plus> <log10> := <log10>;
   <minus> <log10> := (- 0 <log10>);
   <integer>;)

(defcc <lowE>
   {(list number) ==> symbol}
   101 := skip;) 

(define compute-E
    {number --> number --> number}
    N  Log10 -> (* N (expt* 10 Log10)))