Update ScTypes.types with types used in evaluator

20 files changed, 376 insertions, 294 deletions

diff --git a/UTF8.ml b/UTF8.ml
index 4fa5eca..fa02040 100755
--- a/UTF8.ml
+++ b/UTF8.ml
@@ -38,3 +38,15 @@ module Printf = struct
     include Printf

 

 end

+

+module Format = struct

+

+  include Format

+

+  let bprintf buffer fformat = begin

+    let to_b = formatter_of_buffer buffer in

+    let x = fprintf to_b fformat in

+    x

+  end

+

+end

diff --git a/UTF8.mli b/UTF8.mli
index 9e957ac..f91b1fd 100755
--- a/UTF8.mli
+++ b/UTF8.mli
@@ -60,7 +60,13 @@ end
 module Printf : sig

 

   val bprintf : Buffer.buffer -> ('a, Buffer.buffer, unit) format -> 'a

-  

-  val sprintf : ('a, unit, string) format -> 'a

+

+end

+

+module Format: sig

+

+  val formatter_of_buffer : Buffer.buffer -> Format.formatter

+

+  val fprintf : Format.formatter -> ('a, Format.formatter, unit) format -> 'a

 

 end

diff --git a/catalog.ml b/catalog.ml
index 19fb3f4..bd17a18 100755
--- a/catalog.ml
+++ b/catalog.ml
@@ -3,7 +3,7 @@ module type DATA_SIG = sig
 

   type 'a typ

 

-  type 'a result

+  type 'a returnType

 

   val compare_typ: 'a typ -> 'b typ -> ('a, 'b) T.cmp

 

@@ -20,9 +20,9 @@ module Make(Data:DATA_SIG) = struct
   (** This is the way the function is store in the map.

        We just the return type, and the function itself. *)

   type _ t_function =

-    | Fn1: 'b Data.result * ('a -> 'b) -> 'a t_function

-    | Fn2: 'c Data.result * ('a -> 'b -> 'c) -> ('a * 'b) t_function

-    | Fn3: 'd Data.result * ('a -> 'b -> 'c -> 'd) -> ('a * 'b * 'c) t_function

+    | Fn1: 'b Data.returnType * ('a -> 'b) -> 'a t_function

+    | Fn2: 'c Data.returnType * ('a -> 'b -> 'c) -> ('a * 'b) t_function

+    | Fn3: 'd Data.returnType * ('a -> 'b -> 'c -> 'd) -> ('a * 'b * 'c) t_function

 

   (** This is the key for storing functions in the map. *)

   type _ sig_typ =

diff --git a/catalog.mli b/catalog.mli
index d2bb707..d5e5cfd 100644
--- a/catalog.mli
+++ b/catalog.mli
@@ -2,7 +2,7 @@ module type DATA_SIG = sig
 
   type 'a typ
   
-  type 'a result
+  type 'a returnType
   
   val compare_typ: 'a typ -> 'b typ -> ('a, 'b) Tools.cmp
   
@@ -13,9 +13,9 @@ module Make(D:DATA_SIG): sig
   type t
 
   type 'a t_function =
-    | Fn1: 'b D.result * ('a -> 'b) -> 'a t_function
-    | Fn2: 'c D.result * ('a -> 'b -> 'c) -> ('a * 'b) t_function
-    | Fn3: 'd D.result * ('a -> 'b -> 'c -> 'd) -> ('a * 'b * 'c) t_function
+    | Fn1: 'b D.returnType * ('a -> 'b) -> 'a t_function
+    | Fn2: 'c D.returnType * ('a -> 'b -> 'c) -> ('a * 'b) t_function
+    | Fn3: 'd D.returnType * ('a -> 'b -> 'c -> 'd) -> ('a * 'b * 'c) t_function
 
   type 'a sig_typ =
     | T1: 'a D.typ -> 'a t_function sig_typ
@@ -26,7 +26,7 @@ module Make(D:DATA_SIG): sig
   val empty: t
 
   (** Register a new function in the catalog *)
-  val register : t -> string -> 'a sig_typ -> 'a -> t
+  val register : t -> string -> 'a t_function sig_typ -> 'a t_function -> t
 
   (** Find a function with the given name and signature *)
   val find_function: t -> string -> 'a t_function sig_typ -> 'a t_function
diff --git a/date.ml b/date.ml
index 9b24afe..4869f38 100644
--- a/date.ml
+++ b/date.ml
@@ -24,7 +24,7 @@ let get_julian_day year month day = begin
 
 end
 
-let date_from_julian_day day = begin
+let date_from_julian_day (day:Num.num) = begin
 
   let shift_day = Num.floor_num day
     |> Num.add_num (Num.num_of_int 2415019) in
diff --git a/evaluator.ml b/evaluator.ml
index b390771..f2a49d9 100755
--- a/evaluator.ml
+++ b/evaluator.ml
@@ -5,16 +5,12 @@ module Data = struct
 

 (** Data format *)

 

-type _ dataFormat =

-  | Date: D.Num.t dataFormat    (* Date *)

-  | Number: D.Num.t dataFormat  (* Number *)

-  | String: UTF8.t dataFormat   (* String result, there is only one representation *)

-  | Bool: D.Bool.t dataFormat   (* Boolean result *)

+type 'a dataFormat = 'a ScTypes.dataFormat

 

 let most_generic_format: type a. a dataFormat -> a dataFormat -> a dataFormat =

   begin fun a b -> match a, b with

-  | Number, x -> x

-  | x, Number -> x

+  | ScTypes.Number, x -> x

+  | x, ScTypes.Number -> x

   | x, _ -> x

 end

 

@@ -27,13 +23,11 @@ type _ typ =
   | String: UTF8.t typ

   | List: 'a typ -> 'a list typ

 

-let typ_of_format:

-type a. a dataFormat -> a typ =

-function

-  | Date -> Num

-  | Number -> Num

-  | String -> String

-  | Bool -> Bool

+let typ_of_format: type a. a ScTypes.dataFormat -> a typ = function

+  | ScTypes.Date -> Num

+  | ScTypes.Number -> Num

+  | ScTypes.String -> String

+  | ScTypes.Bool -> Bool

 

 let rec compare_typ:

 type a b. a typ -> b typ -> (a, b) T.cmp =

@@ -62,57 +56,35 @@ fun printer typ -> match typ with
   | List t -> Format.fprintf printer "List[%a]"

                 print_typ t

 

-let default_format_for_type: type a. a typ -> a dataFormat = function

-  | Num -> Date

-  | String -> String

-  | Bool -> Bool

+let default_format_for_type: type a. a typ -> a ScTypes.dataFormat = function

+  | Num -> ScTypes.Date

+  | String -> ScTypes.String

+  | Bool -> ScTypes.Bool

   | List _ -> raise Errors.TypeError

   | Unit -> raise Errors.TypeError

 

-(** Results format.

-    Any value which can be encoded with different representation requires as

-    many format than there are representations for this value.

-*)

-

-type _ result =

-  | Numeric: D.Num.t result (* Any numeric format : the representation depends from the inputs  *)

-  | Date: D.Num.t result    (* Date *)

-  | Number: D.Num.t result  (* Number *)

-  | String: UTF8.t result   (* String result, there is only one representation *)

-  | Bool: D.Bool.t result   (* Boolean result *)

+type 'a returnType = 'a ScTypes.returnType

 

-let specialize_result: type a. a result -> a dataFormat -> a result =

+let specialize_result: type a. a ScTypes.returnType -> a ScTypes.dataFormat -> a ScTypes.returnType =

   begin fun a b -> match a, b with

-  | Date, _ -> Date

-  | _, Date -> Date

+  | ScTypes.Num (Some ScTypes.Date) as _1, _ -> _1

+  | _, ScTypes.Date -> ScTypes.Num (Some ScTypes.Date)

   | x, y -> x

 end

 

-let typ_of_result: type a. a result -> a typ = function

-  | Numeric -> Num

-  | Number -> Num

-  | Date -> Num

-  | Bool -> Bool

-  | String -> String

-

-let rec compare_result: type a b. a result -> b result -> (a, b) T.cmp = begin fun a b ->

-  match a, b with

-  | Bool, Bool     -> T.Eq

-  | Numeric, Numeric-> T.Eq

-  | String, String -> T.Eq

-  | Number, Number -> T.Eq

-  | Date, Date -> T.Eq

-  | x, y -> if (T.Ex x) > (T.Ex y) then T.Gt else T.Lt

+let typ_of_result: type a. a ScTypes.returnType -> a typ = function

+  | ScTypes.Num _ -> Num

+  | ScTypes.Bool -> Bool

+  | ScTypes.Str -> String

 

-end

 (*** Values definitions *)

 

 type 'a value =

   | Bool: D.Bool.t -> D.Bool.t value

-  | Num: D.Num.t dataFormat * D.Num.t -> D.Num.t  value

+  | Num: D.Num.t ScTypes.dataFormat * D.Num.t -> D.Num.t value

   | String: UTF8.t -> UTF8.t   value

-  | List: 'a dataFormat * 'a list -> 'a list value

-  | List2: 'a dataFormat * 'a list list -> 'a list list value

+  | List: 'a ScTypes.dataFormat * 'a list -> 'a list value

+  | Matrix: 'a ScTypes.dataFormat * 'a list list -> 'a list list value

 

 (** Get the value out of the box *)

 let get_value_content: type a. a value -> a = function

@@ -120,17 +92,7 @@ let get_value_content: type a. a value -> a = function
   | Num (_, n) -> n

   | String s -> s

   | List (t, l) -> l

-  | List2 (t, l) -> l

-

-(** Create a value from a known type and an unboxed value *)

-let build_value: type a. a dataFormat -> a -> a value = begin fun format content ->

-  match (typ_of_format format), content with

-    | Unit, _ -> raise Errors.TypeError

-    | Bool, x -> Bool x

-    | Num, x -> Num (format, x)

-    | String, s -> String s

-    | List t, l -> raise Errors.TypeError

-end

+  | Matrix (t, l) -> l

 

 (* Extract the type from a boxed value *)

 let type_of_value: type a. a value -> a typ = function

@@ -138,54 +100,53 @@ let type_of_value: type a. a value -> a typ = function
   | Num (n, _) -> Num

   | String s -> String

   | List (t, l) -> List (typ_of_format t)

-  | List2 (t, l) -> List (List (typ_of_format t))

+  | Matrix (t, l) -> List (List (typ_of_format t))

 

-let format_of_value: type a. a value -> a dataFormat = function

-  | Bool b -> Bool

+let format_of_value: type a. a value -> a ScTypes.dataFormat = function

+  | Bool b -> ScTypes.Bool

   | Num (f, _) -> f

-  | String s -> String

+  | String s -> ScTypes.String

   | List (t, l)  -> raise Errors.TypeError

-  | List2 (t, l) -> raise Errors.TypeError

+  | Matrix (t, l) -> raise Errors.TypeError

 

-  let inject':

-  type a. a result -> (unit -> a dataFormat) -> a -> a value =

+let inject':

+  type a. a ScTypes.returnType -> (unit -> a ScTypes.dataFormat) -> a -> a value =

   fun resultFormat f res -> begin match resultFormat, res with

-    | Bool, x -> Bool x

-    | Numeric, x -> Num (f (), x)

-    | Date, x -> Num(Date, x)

-    | Number, x -> Num(Number, x)

-    | String, s -> String s

+    | ScTypes.Bool, x -> Bool x

+    | ScTypes.Str, s -> String s

+    | ScTypes.Num None, x -> Num (f (), x)

+    | ScTypes.Num (Some v), x -> Num(v, x)

     end

 

-let compare_format: type a b. a typ -> a result -> b value -> a result = begin

+let compare_format: type a b. a typ -> a ScTypes.returnType -> b value -> a ScTypes.returnType = begin

 fun init_typ currentResult value ->

 

-(* If the argument as the same type as the result format, just the most specialized *)

-match compare_typ init_typ (type_of_value value) with

-  | T.Eq -> begin match value with

-    | Bool b -> Bool

-    | String s -> String

-    | Num (f, v) -> specialize_result currentResult f

-    (* There is no possibility to get init_typ as List typ*)

-    | List (f, v) -> raise Errors.TypeError

-    | List2 (f, v) -> raise Errors.TypeError

-    end

-  (* The types differ, handle the special cases for Lists *)

-  | _ ->

-    begin match value with

-    | List (f, v) ->

-      begin match compare_typ init_typ (typ_of_format f) with

-      | T.Eq -> specialize_result currentResult f

-      | _ -> currentResult

+  (* If the argument as the same type as the result format, just select the most specialized *)

+  match compare_typ init_typ (type_of_value value) with

+    | T.Eq -> begin match value with

+      | Bool b -> ScTypes.Bool

+      | String s -> ScTypes.Str

+      | Num (f, v) -> specialize_result currentResult f

+      (* There is no possibility to get init_typ as List typ*)

+      | List (f, v) -> raise Errors.TypeError

+      | Matrix (f, v) -> raise Errors.TypeError

       end

-    | List2 (f, v) ->

-      begin match compare_typ init_typ (typ_of_format f) with

-      | T.Eq -> specialize_result currentResult f

+    (* The types differ, handle the special cases for Lists *)

+    | _ ->

+      begin match value with

+      | List (f, v) ->

+        begin match compare_typ init_typ (typ_of_format f) with

+        | T.Eq -> specialize_result currentResult f

+        | _ -> currentResult

+        end

+      | Matrix (f, v) ->

+        begin match compare_typ init_typ (typ_of_format f) with

+        | T.Eq -> specialize_result currentResult f

+        | _ -> currentResult

+        end

       | _ -> currentResult

       end

-    | _ -> currentResult

-    end

-end

+  end

 

 end

 

@@ -201,28 +162,27 @@ type existencialResult =
     The most specialized format take over the others.

 *)

 let guess_format_result:

-type a. a Data.result -> existencialResult list -> unit -> a Data.dataFormat =

+type a. a ScTypes.returnType -> existencialResult list -> unit -> a Data.dataFormat =

 begin fun init_value values () ->

 

   let init_typ:a Data.typ = Data.typ_of_result init_value in

 

   (* fold over the arguments, and check if they have the same format *)

-  let compare_format: a Data.result -> existencialResult -> a Data.result =

+  let compare_format: a ScTypes.returnType -> existencialResult -> a ScTypes.returnType =

   fun currentResult (Result value) ->

     Data.compare_format init_typ currentResult value in

 

   begin match List.fold_left compare_format init_value values with

-  | Data.String -> Data.String

-  | Data.Bool -> Data.Bool

-  | Data.Number -> Data.Number

-  | Data.Date -> Data.Date

-  | Data.Numeric -> Data.Number

+  | ScTypes.Str    -> ScTypes.String

+  | ScTypes.Bool   -> ScTypes.Bool

+  | ScTypes.Num None-> ScTypes.Number

+  | ScTypes.Num (Some x)-> x

   end

 

 end

 

 let inject:

-type a. a Data.result -> (unit -> a Data.dataFormat) -> a -> existencialResult =

+type a. a Data.returnType -> (unit -> a Data.dataFormat) -> a -> existencialResult =

 fun resultFormat f res ->

   let (x:a Data.value) = Data.inject' resultFormat f res in

   Result x

@@ -242,7 +202,6 @@ let register3 name (typ1, typ2, typ3) result f =
 let call name args = begin

   let name' = UTF8.to_utf8string name in

   begin try match args with

-

   | [] ->

     let C.Fn1(ret, f) = C.find_function !catalog name' (C.T1 Data.Unit) in

     inject ret (fun () -> raise Errors.TypeError) (f ())

@@ -278,19 +237,19 @@ let repr mapper value = begin
   (** Extract the value from a raw type.

       If the value is Undefined, raise an exception.

    *)

-  let extract_value = begin function

-    | ScTypes.Num (n,s) -> Result (Data.Num (Data.Number, (D.Num.of_num n)))

-    | ScTypes.Bool b    -> Result (Data.Bool b)

-    | ScTypes.Date d    -> Result (Data.Num (Data.Date, (D.Num.of_num d)))

-    | ScTypes.Str s     -> Result (Data.String s)

+  let extract_value : ScTypes.result -> existencialResult = begin function

+    | ScTypes.Result (ScTypes.Num (f, n)) -> Result (Data.Num (f, n))

+    | ScTypes.Result (ScTypes.Bool b)    -> Result (Data.Bool b)

+    | ScTypes.Result (ScTypes.Str s)     -> Result (Data.String s)

+    | ScTypes.Error x -> raise x

   end in

 

-  let add_elem: type a. a Data.typ -> a list * a Data.dataFormat -> ScTypes.types option -> a list * a Data.dataFormat =

+  let add_elem: type a. a Data.typ -> a list * a Data.dataFormat -> ScTypes.result option -> a list * a Data.dataFormat =

   begin fun type_of (result, format_of) next ->

     let Result r = match next with

     | Some x -> extract_value x

     | None -> begin match type_of with

-      | Data.Num  ->   Result (Data.Num (Data.Number, (D.Num.nan)))

+      | Data.Num  ->   Result (Data.Num (ScTypes.Number, D.Num.nan))

       | Data.Bool ->   Result (Data.Bool false)

       | Data.String -> Result (Data.String (UTF8.empty))

       | Data.List x  -> Result (Data.List ((Data.default_format_for_type x), []))

@@ -304,26 +263,6 @@ let repr mapper value = begin
     end

   end in

 

-  (* Return the result for any expression as an ScTypes.types result *)

-  let rec get_repr: type a. a Data.value -> ScTypes.types = begin function

-  | Data.Bool b ->  ScTypes.Bool b

-  | Data.Num (format, n)  ->  begin match format with

-    | Data.Number -> ScTypes.Num (D.Num.to_num n, None)

-    | Data.Date -> ScTypes.Date (D.Num.to_num n)

-    | _ -> raise Errors.TypeError (* This pattern could be refuted *)

-    end

-  | Data.String s -> ScTypes.Str s

-  | Data.List (t, l) ->

-         List.hd l            (* Extract the first element *)

-      |> Data.build_value t   (* Convert it in boxed value *)

-      |> get_repr             (* Return it's representation *)

-  | Data.List2 (t, l) ->

-         List.hd l            (* Extract the first element *)

-      |> List.hd

-      |> Data.build_value t   (* Convert it in boxed value *)

-      |> get_repr             (* Return it's representation *)

-  end in

-

   (** Extract the value from an expression.

       [extract typ expr] will evaluate the expression and return it. If the

       result cannot be evaluated (because of references pointing to missing

@@ -341,8 +280,8 @@ let repr mapper value = begin
         | ScTypes.Refs.Array1 l ->

           (* Guess the list type from it's first defined element *)

           let Result r = extract_value (Tools.List.find_map (fun x -> x) l) in

-          let format_of = Data.format_of_value r in

-          let type_of = Data.type_of_value r in

+          let format_of = Data.format_of_value r

+          and type_of = Data.type_of_value r in

           (* Build the list with all the elements *)

           let elems, format = List.fold_left (add_elem type_of) ([], format_of) l in

           Result (Data.List (format, elems))

@@ -350,26 +289,31 @@ let repr mapper value = begin
           (* Guess the list type from it's first defined element *)

           let Result r = extract_value (Tools.List.find_map2 (fun x -> x) l) in

 

-          let format_of = Data.format_of_value r in

-          let type_of = Data.type_of_value r in

+          let format_of = Data.format_of_value r

+          and type_of = Data.type_of_value r in

           (* Build the list with all the elements *)

           let elems, format = List.fold_left (fun (result, format_of) elems ->

             let elems, format = List.fold_left (add_elem type_of) ([], format_of) elems in

             elems::result, (Data.most_generic_format format_of format)

-            ) ([], format_of) l in

-          Result (Data.List2 (format, elems))

+          ) ([], format_of) l in

+          Result (Data.Matrix (format, elems))

         end

 

     (* Evaluate the expression *)

     | ScTypes.Expression e -> extract e

-    | ScTypes.Value v -> extract_value v

+    | ScTypes.Value v -> extract_value (ScTypes.Result v)

     | ScTypes.Call (name, args) ->

         let args' = List.map extract args in

         call name args'

     end

   in

-  let Result r = extract value in

-  get_repr r

+  let Result r = (extract value) in

+  begin match r with

+  | Data.Bool b ->  ScTypes.Result (ScTypes.Bool b)

+  | Data.Num (format, n)  ->  ScTypes.Result (ScTypes.Num (format, n))

+  | Data.String s -> ScTypes.Result (ScTypes.Str s)

+  | _ -> raise Errors.TypeError

+  end

 end

 

 let wrap f =

@@ -380,13 +324,13 @@ let wrap f =
 

 

 (* Register the standard functions *)

-type 'a result = 'a Data.result

+type 'a returnType = 'a ScTypes.returnType

 

-let f_num: DataType.Num.t Data.result  = Data.Numeric

-let f_date: DataType.Num.t Data.result = Data.Date

-let f_number: DataType.Num.t Data.result = Data.Number

-let f_string: DataType.String.t Data.result = Data.String

-let f_bool: DataType.Bool.t Data.result = Data.Bool

+let f_num = ScTypes.f_num

+let f_date = ScTypes.f_date

+let f_number = ScTypes.f_number

+let f_string = ScTypes.f_string

+let f_bool = ScTypes.f_bool

 

 module Make_Compare(C: D.COMPARABLE) = struct

 

@@ -468,7 +412,7 @@ let () = begin
   (* Build a date *)

   register3 "date"  (t_int, t_int, t_int) f_date (

     fun year month day ->

-      Tools.Date.get_julian_day

+      Date.get_julian_day

         (Num.int_of_num @@ Num.floor_num @@ D.Num.to_num year)

         (Num.int_of_num @@ Num.floor_num @@ D.Num.to_num month)

         (Num.int_of_num @@ Num.floor_num @@ D.Num.to_num day)

diff --git a/evaluator.mli b/evaluator.mli
index d695b68..de03ffc 100755
--- a/evaluator.mli
+++ b/evaluator.mli
@@ -1,4 +1,4 @@
-val repr: (ScTypes.refs -> ScTypes.types option ScTypes.Refs.range) -> ScTypes.expression -> ScTypes.types

+val repr: (ScTypes.refs -> ScTypes.result option ScTypes.Refs.range) -> ScTypes.expression -> ScTypes.result

 

 (** Type definitions *)

 

@@ -10,49 +10,49 @@ val t_list: 'a typ -> 'a list typ
 

 (** Result formats *)

 

-type 'a result

+type 'a returnType

 

 (** Numeric (any format) *)

-val f_num: DataType.Num.t result

+val f_num: DataType.Num.t returnType

 

 (** Date *)

-val f_date: DataType.Num.t result

+val f_date: DataType.Num.t returnType

 

 (** Number *)

-val f_number: DataType.Num.t result

+val f_number: DataType.Num.t returnType

 

 (** Boolean result *)

-val f_bool: DataType.Bool.t result

+val f_bool: DataType.Bool.t returnType

 

 (** String *)

-val f_string: DataType.String.t result

+val f_string: DataType.String.t returnType

 

 (** Catalog *)

 

 val register0: 

   string ->           (* The function name *)

-  'a result ->        (* The return type *)

+  'a returnType ->        (* The return type *)

   (unit -> 'a)        (* The function to call *)

   -> unit

 

 val register1: 

   string ->           (* The function name *)

   'a typ ->           (* The signature *)

-  'b result ->        (* The return type *)

+  'b returnType ->        (* The return type *)

   ('a -> 'b)          (* The function to call *)

   -> unit

 

 val register2: 

   string ->           (* The function name *)

   ('a typ * 'b typ) ->(* The signature *)

-  'c result ->        (* The return type *)

+  'c returnType ->        (* The return type *)

   ( 'a -> 'b -> 'c)   (* The function to call*)

   -> unit

 

 val register3: 

   string ->           (* The function name *)

   ('a typ * 'b typ * 'c typ) ->(* The signature *)

-  'd result ->           (* The return type *)

+  'd returnType ->           (* The return type *)

   ( 'a -> 'b -> 'c -> 'd)   (* The function to call*)

   -> unit

 

diff --git a/expression.ml b/expression.ml
index 0bc8f43..31b6369 100755
--- a/expression.ml
+++ b/expression.ml
@@ -3,9 +3,9 @@ module Tuple2 = Tools.Tuple2
 let u = UTF8.from_utf8string

 

 type t =

-  | Basic of ScTypes.types            (** A direct type *)

-  | Formula of formula                (** A formula *)

-  | Undefined                         (** The content is not defined *)

+  | Basic: 'a ScTypes.types -> t           (** A direct type *)

+  | Formula: formula -> t               (** A formula *)

+  | Undefined: t                         (** The content is not defined *)

 

 and formula =

   | Expression of ScTypes.expression  (** A valid expression *)

@@ -33,11 +33,12 @@ let load content = begin
       let content' =

         try String.sub content 0 (String.index content '\000')

         with Not_found -> content in

-      Basic (

-        try       Lexing.from_string content'

-                |> ExpressionParser.content ExpressionLexer.read

-        with _ -> ScTypes.Str (UTF8.from_utf8string content')

-      )

+        try

+          let ScTypes.Result r =

+               ExpressionParser.content ExpressionLexer.read

+            @@ Lexing.from_string content' in

+          Basic r

+        with _ -> Basic (ScTypes.Str (UTF8.from_utf8string content'))

     )

   ) else (

     (* If the string in empty, build an undefined value *)

@@ -58,7 +59,7 @@ let eval expr sources = begin
 

   begin try match expr with

     | Basic value -> ScTypes.Result value

-    | Formula (Expression f) -> ScTypes.Result (eval_exp f)

+    | Formula (Expression f) -> eval_exp f

     | Formula (Error (i, s)) -> ScTypes.Error ScTypes.Error

     | Undefined -> ScTypes.Error Not_found

     with ex -> ScTypes.Error ex

diff --git a/expression.mli b/expression.mli
index e54d2a0..8cab479 100755
--- a/expression.mli
+++ b/expression.mli
@@ -1,7 +1,7 @@
 type t =

-  | Basic of ScTypes.types            (** A direct type *)

-  | Formula of formula                (** A formula *)

-  | Undefined                         (** The content is not defined *)

+  | Basic: 'a ScTypes.types -> t           (** A direct type *)

+  | Formula: formula -> t               (** A formula *)

+  | Undefined: t                         (** The content is not defined *)

 

 and formula =

   | Expression of ScTypes.expression  (** A valid expression *)

@@ -16,7 +16,7 @@ val load_expr: t -> t
 val is_defined: t -> bool

 

 (** Evaluate the expression *)

-val eval: t -> (ScTypes.refs -> ScTypes.types option ScTypes.Refs.range) -> ScTypes.result

+val eval: t -> (ScTypes.refs -> ScTypes.result option ScTypes.Refs.range) -> ScTypes.result

 

 (** Collect all the cell referenced in the expression *)

 val collect_sources: t -> Cell.Set.t

diff --git a/expressionParser.mly b/expressionParser.mly
index f85f44f..303e683 100755
--- a/expressionParser.mly
+++ b/expressionParser.mly
@@ -35,7 +35,7 @@
 %left POW
 
 %start<ScTypes.expression> value
-%start<ScTypes.types> content
+%start<ScTypes.result> content
 
 %%
 
@@ -46,26 +46,33 @@ content:
   | basic EOF               {$1}
 
 basic:
-  | num                     {Num ((snd $1), Some (u(fst $1)))}
-  | MINUS num               {Num (Num.minus_num (snd $2), Some (u("-" ^(fst $2)) ))}
-  | PLUS num                {Num ((snd $2), Some (u(fst $2)))}
-  | NUM DIVIDE NUM DIVIDE NUM {
-                              Date (Tools.Date.get_julian_day 
-                                (Num.int_of_num @@ snd $1)
-                                (Num.int_of_num @@ snd $3)
-                                (Num.int_of_num @@ snd $5)
-                              )}
-  | NUM COLON NUM COLON NUM {
-      Date (Num.(
-      let nhour = (snd $1) // (num_of_int 24)
-      and nmin  = (snd $3) // (num_of_int 1440)
-      and nsec  = (snd $5) // (num_of_int 86400) 
-      in nhour +/ nmin +/ nsec
-      ))
-    }
+  | PLUS num                {Result (Num (ScTypes.Number, (DataType.Num.of_num (snd $2))))}
+  | MINUS num               {Result (Num (ScTypes.Number, (DataType.Num.of_num @@ Num.minus_num (snd $2))))}
+  | num                     {Result (Num (ScTypes.Number, (DataType.Num.of_num (snd $1))))}
+  | NUM DIVIDE NUM DIVIDE NUM {Result (
+      Num (
+        ScTypes.Date,
+        DataType.Num.of_num @@ (Date.get_julian_day 
+          (Num.int_of_num @@ snd $1)
+          (Num.int_of_num @@ snd $3)
+          (Num.int_of_num @@ snd $5)
+        )))}
+  | NUM COLON NUM COLON NUM {Result (
+      Num (
+        ScTypes.Date,
+        (Num.(
+        let nhour = (snd $1) // (num_of_int 24)
+        and nmin  = (snd $3) // (num_of_int 1440)
+        and nsec  = (snd $5) // (num_of_int 86400) 
+        in DataType.Num.of_num @@ nhour +/ nmin +/ nsec))
+      )
+  )}
 
 expr:
-  | num                     {Value (Num ((snd $1), Some (u(fst $1))))}
+  | num                     {Value (Num (
+      ScTypes.Number, 
+      DataType.Num.of_num (snd $1)
+  ))}
   | MINUS expr              {Call (F.sub, [$2])}
   | PLUS expr               {Call (F.add, [$2])}
 
diff --git a/odf/odf.ml b/odf/odf.ml
index 7af44a9..b091bc9 100755
--- a/odf/odf.ml
+++ b/odf/odf.ml
@@ -31,10 +31,14 @@ let load_formula formula =
 let load_content content = begin function

   | "float" -> Expression.Basic (

       ScTypes.Num (

-        (Tools.Num.of_float_string content), Some (u @@ Tools.String.filter_float content)))

+        ScTypes.Number,

+        DataType.Num.of_num (Tools.Num.of_float_string content)

+      ))

   | "date"  -> Expression.Basic (

-      ScTypes.Date (

-        Tools.Date.from_string content))

+      ScTypes.Num (

+        ScTypes.Date,

+        DataType.Num.of_num (Tools.Num.of_float_string content)

+      ))

   | _ -> Expression.Basic (

       ScTypes.Str (

         UTF8.from_utf8string content))

@@ -164,15 +168,19 @@ let write_bool  = write_type "bool"   "bool"
 let write_error = write_type "string" "error"

 let write_date  = write_type "date"   "date"

 

-let write_basic attrs output = begin function

-  | ScTypes.Num (n,_)  ->

-      let value = (string_of_float @@ Num.float_of_num n) in

-      write_num ((NS.value_attr, value)::attrs) output value

+let write_basic: type a. 'b list -> Xmlm.output -> a ScTypes.types -> unit = fun attrs output types -> begin match types with

   | ScTypes.Str s  -> write_str  attrs output (UTF8.to_utf8string s)

   | ScTypes.Bool b -> write_bool attrs output (string_of_bool b)

-  | ScTypes.Date d ->

-      let value = Tools.Date.to_string d in

+  | ScTypes.Num (data_type, d)  ->

+    let n = DataType.Num.to_num d in

+    begin match ScTypes.get_numeric_type data_type with

+    | ScTypes.Number ->

+      let value = (string_of_float @@ Num.float_of_num n) in

+      write_num ((NS.value_attr, value)::attrs) output value

+    | ScTypes.Date ->

+      let value = Date.to_string n in

       write_date ((NS.date_value_attr, value)::attrs) output value

+    end

 end

 

 let write_formula output attrs f = begin function

@@ -191,17 +199,21 @@ let print_ref buffer c =
   end;

   UTF8.Buffer.add_string buffer @@ u"]"

 

-let rec print_expr buffer = begin function

-  | ScTypes.Value (ScTypes.Num (n, _))  ->

-      UTF8.Buffer.add_string buffer @@ u(string_of_float @@ Num.float_of_num n)

+let rec print_expr : UTF8.Buffer.buffer -> ScTypes.expression -> unit = fun buffer -> begin function

   | ScTypes.Value (ScTypes.Str s)  ->

       UTF8.Printf.bprintf buffer "\"%s\"" (UTF8.to_utf8string s)

   | ScTypes.Value (ScTypes.Bool b) ->

        u(string_of_bool b)

     |> UTF8.Buffer.add_string buffer

-  | ScTypes.Value (ScTypes.Date d) ->

-        u(Tools.Date.to_string d)

-    |> UTF8.Buffer.add_string buffer

+  | ScTypes.Value (ScTypes.Num (data_type, d))  ->

+    let n = DataType.Num.to_num d in

+    begin match ScTypes.get_numeric_type data_type with

+    | ScTypes.Number  ->

+        UTF8.Buffer.add_string buffer @@ u(string_of_float @@ Num.float_of_num n)

+    | ScTypes.Date  ->

+          u(Date.to_string n)

+      |> UTF8.Buffer.add_string buffer

+    end

   | ScTypes.Ref r -> print_ref buffer r

   | ScTypes.Expression x ->

       UTF8.Buffer.add_char buffer '(';

diff --git a/odf/odf_ExpressionParser.mly b/odf/odf_ExpressionParser.mly
index 9731699..1b60e1c 100755
--- a/odf/odf_ExpressionParser.mly
+++ b/odf/odf_ExpressionParser.mly
@@ -43,7 +43,10 @@ value:
   | LETTERS COLON EQ expr EOF {$4}
 
 expr:
-  | num                     {Value (Num ((snd $1), Some (u(fst $1))))}
+  | num                     {Value (Num (
+        Number, 
+        DataType.Num.of_num @@ snd $1
+        ))}
   | MINUS expr              {Call (F.sub, [$2])}
   | PLUS expr               {Call (F.add, [$2])}
 
diff --git a/scTypes.ml b/scTypes.ml
index 869df8b..f8c3d38 100755
--- a/scTypes.ml
+++ b/scTypes.ml
@@ -8,36 +8,79 @@ type cell = Cell.t
 
 type ident = UTF8.t
 
-type types =
-  | Num  of Num.num * (UTF8.t option)     (** A number *)
-  | Str  of UTF8.t                        (** A string *)
-  | Date of Num.num                       (** A date in julian day *)
-  | Bool of bool                          (** A boolean *)
+type 'a number_format = (float -> 'a, Format.formatter, unit) format
+
+type _ dataFormat =
+  | Date:   DataType.Num.t dataFormat   (* Date *)
+  | Number: DataType.Num.t dataFormat   (* Number *)
+  | String: DataType.String.t dataFormat           (* String result, there is only one representation *)
+  | Bool:   DataType.Bool.t dataFormat  (* Boolean result *)
+
+type numericType =
+  | Date
+  | Number
+
+let get_numeric_type: DataType.Num.t dataFormat -> numericType = function
+  | Date -> Date
+  | Number -> Number
+
+let priority: type a. a dataFormat -> int = function
+  | Date   -> 1
+  | Number -> 0
+  | String -> 0
+  | Bool   -> 0
+
+type 'a types =
+  | Num  : DataType.Num.t dataFormat * DataType.Num.t -> DataType.Num.t types    (** A number *)
+  | Str  : DataType.String.t -> DataType.String.t types                     (** A string *)
+  | Bool : DataType.Bool.t -> DataType.Bool.t types                         (** A boolean *)
+
+type 'a returnType =
+  | Num  : DataType.Num.t dataFormat option -> DataType.Num.t returnType    (** A number *)
+  | Str  : DataType.String.t returnType                                     (** A string *)
+  | Bool : DataType.Bool.t returnType                                       (** A boolean *)
+
+let f_num: DataType.Num.t returnType  = Num None
+let f_date: DataType.Num.t returnType = Num (Some Date)
+let f_number: DataType.Num.t returnType = Num (Some Number)
+let f_string: DataType.String.t returnType = Str
+let f_bool: DataType.Bool.t returnType = Bool
+
+type typeContainer =
+  | Value: 'a types -> typeContainer
+
+let guess_format_result:
+  type a. a returnType -> typeContainer list -> (a -> a types) =
+  fun return params -> begin match return with
+  | Str -> fun value -> Str value
+  | Bool -> fun value -> Bool value
+  | Num (Some x) -> fun value -> Num (x, value)
+  | Num None -> fun value -> Num (Number, value)
+end
 
 type refs =
-  | Cell of cell                (** A cell *)
-  | Range of cell * cell        (** An area of cells *)
+  | Cell of cell                                      (** A cell *)
+  | Range of cell * cell                              (** An area of cells *)
 
 type expression =
-  | Value of types                  (** A direct value *)
-  | Ref of refs                     (** A reference to another cell *)
-  | Call of ident * expression list (** A call to a function *)
-  | Expression of expression        (** An expression *)
+  | Value : 'a types -> expression                    (** A direct value *)
+  | Ref : refs -> expression                          (** A reference to another cell *)
+  | Call : ident * expression list -> expression      (** A call to a function *)
+  | Expression : expression -> expression             (** An expression *)
 
 (** Result from a computation *)
 type result =
-  | Result of types
-  | Error of exn
+  | Result : 'a types -> result
+  | Error : exn -> result
 
 module Type = struct
   (* Required because Num.Big_int cannot be compared with Pervasives.(=) *)
-  let (=) t1 t2 =
+  let (=) : type a b. a types -> b types -> bool = fun t1 t2 ->
     match t1, t2 with
-    | Num (n1,_), Num (n2,_) -> Num.eq_num n1 n2
-    | Date n1, Date n2 -> Num.eq_num n1 n2
-    | Num _, Date n2 -> false
-    | Date n1, Num _ -> false
-    | _, _ -> t1 = t2
+    | Num (_, n1), Num (_, n2) -> DataType.Num.eq n1 n2
+    | Bool b1, Bool b2 -> b1 = b2
+    | Str s1, Str s2 -> s1 = s2
+    | _, _ -> false
 
   (** Show a list of elements
    *)
@@ -52,20 +95,19 @@ module Type = struct
         show_list printer buffer tl
   end
 
-  and show buffer = begin function
-    | Num (n,x)     ->
-      begin match x with
-      | Some value -> UTF8.Buffer.add_string buffer value
-      | None ->
-        if Num.is_integer_num n then
-          UTF8.Buffer.add_string buffer @@ u(Num.string_of_num n)
-        else
-          UTF8.Printf.bprintf buffer "%.*f" 2 (Num.float_of_num n)
-      end
+  and show: type a. UTF8.Buffer.buffer -> a types -> unit = fun buffer -> begin function
     | Str x     -> UTF8.Buffer.add_string buffer x
     | Bool b    -> UTF8.Printf.bprintf buffer "%B" b
-    | Date n    ->
-        let y, m, d = Tools.Date.date_from_julian_day n in
+    | Num (Number, n)     ->
+      let n = DataType.Num.to_num n in
+      if Num.is_integer_num n then
+        UTF8.Buffer.add_string buffer @@ u(Num.string_of_num n)
+      else
+        let to_b = UTF8.Format.formatter_of_buffer buffer in
+        ignore @@ UTF8.Format.fprintf to_b "%.2f" (Num.float_of_num n);
+        Format.pp_print_flush to_b ()
+    | Num (Date, n)    ->
+        let y, m, d = Date.date_from_julian_day (DataType.Num.to_num n) in
         UTF8.Printf.bprintf buffer "%d/%d/%d" y m d
   end
 
diff --git a/scTypes.mli b/scTypes.mli
index 1d8fe54..17b51eb 100755
--- a/scTypes.mli
+++ b/scTypes.mli
@@ -6,32 +6,70 @@ type cell = (int * int) * (bool * bool)
 

 type ident = UTF8.t

 

-type types =

-  | Num  of Num.num * (UTF8.t option)     (** A number *)

-  | Str  of UTF8.t                        (** A string *)

-  | Date of Num.num                       (** A date in julian day *)

-  | Bool of bool                          (** A boolean *)

+type 'a number_format = (float -> 'a, Format.formatter, unit) format

+

+type 'a dataFormat =

+  | Date: DataType.Num.t dataFormat    (* A date in julian day *)

+  | Number: DataType.Num.t dataFormat  (* Number *)

+  | String: DataType.String.t dataFormat (* String result, there is only one representation *)

+  | Bool: DataType.Bool.t dataFormat   (* Boolean result *)

+

+type 'a returnType =

+  | Num  : DataType.Num.t dataFormat option -> DataType.Num.t returnType    (** A number *)

+  | Str  : DataType.String.t returnType                                     (** A string *)

+  | Bool : DataType.Bool.t returnType                                       (** A boolean *)

+

+type numericType =

+  | Date

+  | Number

+

+val get_numeric_type: DataType.Num.t dataFormat -> numericType

+

+type 'a types =

+  | Num  : DataType.Num.t dataFormat * DataType.Num.t -> DataType.Num.t types    (** A number *)

+  | Str  : DataType.String.t -> DataType.String.t types                        (** A string *)

+  | Bool : DataType.Bool.t -> DataType.Bool.t types                         (** A boolean *)

+

+type typeContainer =

+  | Value: 'a types -> typeContainer

+

+

+(** Numeric (any format) *)

+val f_num: DataType.Num.t returnType

+

+(** Date *)

+val f_date: DataType.Num.t returnType

+

+(** Number *)

+val f_number: DataType.Num.t returnType

+

+(** Boolean result *)

+val f_bool: DataType.Bool.t returnType

+

+(** String *)

+val f_string: DataType.String.t returnType

 

 type refs =

   | Cell of cell                          (** A cell *)

   | Range of cell * cell                  (** An area of cells *)

 

+(** This is the cell content *)

 type expression =

-  | Value of types                        (** A direct value *)

-  | Ref of refs                           (** A reference to another cell *)

-  | Call of ident * expression list       (** A call to a function *)

-  | Expression of expression              (** An expression *)

+  | Value : 'a types -> expression                    (** A direct value *)

+  | Ref : refs -> expression                          (** A reference to another cell *)

+  | Call : ident * expression list -> expression      (** A call to a function *)

+  | Expression : expression -> expression             (** An expression *)

 

 (** Result from a computation *)

 type result =

-  | Result of types

-  | Error of exn

+  | Result : 'a types -> result

+  | Error : exn -> result

 

 module Type : sig

 

-  val (=) : types -> types -> bool

+  val (=) : 'a types -> 'b types -> bool

 

-  val show: UTF8.Buffer.buffer -> types -> unit

+  val show: UTF8.Buffer.buffer -> 'a types -> unit

 

 end

 

diff --git a/sheet.ml b/sheet.ml
index 22446e5..67b1ee1 100755
--- a/sheet.ml
+++ b/sheet.ml
@@ -48,15 +48,10 @@ module Raw = struct
   (** Extract a value from a reference.

       This function is given to the evaluator for getting the values from a reference.

    *)

-  let get_ref from t ref : ScTypes.types option ScTypes.Refs.range = begin

-

-    let extract_values = begin function

-      | ScTypes.Result v -> v

-      | ScTypes.Error e -> raise e

-    end in

+  let get_ref from t ref : ScTypes.result option ScTypes.Refs.range = begin

 

     ScTypes.Refs.collect ref

-      |> ScTypes.Refs.map (fun coord -> Option.map extract_values (get_value coord t))

+      |> ScTypes.Refs.map (fun coord -> get_value coord t)

 

   end

 

diff --git a/tests/expressionParser_test.ml b/tests/expressionParser_test.ml
index 25d9d00..476e3aa 100755
--- a/tests/expressionParser_test.ml
+++ b/tests/expressionParser_test.ml
@@ -21,7 +21,9 @@ let test_num ctx = begin
     Expression.Expression (
       ScTypes.Value (
         ScTypes.Num (
-          Num.num_of_int 1, Some (u"1"))))) in
+          ScTypes.Number,
+          DataType.Num.of_num (Num.num_of_int 1)
+      )))) in
   let result = load_expr "=1" in
 
   assert_equal
@@ -52,7 +54,10 @@ let test_call2 ctx = begin
   let expected = Expression.Formula (
     Expression.Expression (
       ScTypes.Call (
-        u"foo2", [ScTypes.Value (ScTypes.Num (Num.num_of_int 4, Some (u"4")))]))) in
+        u"foo2", [ScTypes.Value (ScTypes.Num (
+          ScTypes.Number,
+          DataType.Num.of_num (Num.num_of_int 4)
+        ))]))) in
   let result = load_expr "=foo2(4)" in
 
   assert_equal
diff --git a/tests/expression_test.ml b/tests/expression_test.ml
index 3f00e67..0950383 100755
--- a/tests/expression_test.ml
+++ b/tests/expression_test.ml
@@ -6,11 +6,11 @@ let u = UTF8.from_utf8string
 let _msg ~expected ~result =
 
     let get_type = function
-    | Expression.Basic ScTypes.Num _      -> "N"
-    | Expression.Basic ScTypes.Str _      -> "S"
-    | Expression.Basic ScTypes.Date _     -> "D"
-    | Expression.Basic ScTypes.Bool _     -> "B"
-    | Expression.Formula _                -> "F" in
+    | Expression.Basic ScTypes.Num (ScTypes.Number, _) -> "N"
+    | Expression.Basic ScTypes.Num (ScTypes.Date, _)     -> "D"
+    | Expression.Basic ScTypes.Str _                       -> "S"
+    | Expression.Basic ScTypes.Bool _                      -> "B"
+    | Expression.Formula _                                 -> "F" in
 
     Printf.sprintf "Expected %s:%s but got %s:%s"
     (UTF8.raw_encode @@ Expression.show expected)
@@ -52,7 +52,10 @@ end
 let test_num ctx = begin
   let result = Expression.load @@ u"123" in
   let expected = Expression.load_expr @@ Expression.Basic (
-    ScTypes.Num (Num.num_of_int 123, None)) in
+    ScTypes.Num (
+      ScTypes.Number,
+      DataType.Num.of_num @@ Num.num_of_int 123
+    )) in
   assert_equal expected result
 end
 
@@ -60,21 +63,29 @@ let test_float ctx = begin
   let result = Expression.load @@ u"12.45" in
   let expected = Expression.load_expr @@ Expression.Basic (
     ScTypes.Num (
-      T.Num.of_float_string "12.45", None)) in
+      ScTypes.Number,
+      DataType.Num.of_num @@ T.Num.of_float_string "12.45"
+    )) in
   assert_equal expected result
 end
 
 let test_relative ctx = begin
   let result = Expression.load @@ u"-123" in
   let expected = Expression.load_expr @@ Expression.Basic (
-    ScTypes.Num (Num.num_of_int (-123), None)) in
+    ScTypes.Num (
+      ScTypes.Number,
+      DataType.Num.of_num @@ Num.num_of_int (-123)
+    )) in
   assert_equal expected result
 end
 
 let test_date ctx = begin
   let result = Expression.load @@ u"1900/01/01"
   and expected = Expression.load_expr @@ Expression.Basic (
-    ScTypes.Date (Tools.Date.get_julian_day 1900 01 01)) in
+    ScTypes.Num (
+      ScTypes.Date,
+      DataType.Num.of_num @@ Date.get_julian_day 1900 01 01
+    )) in
   assert_equal expected result
 end
 
diff --git a/tests/odf/odf_ExpressionParser_test.ml b/tests/odf/odf_ExpressionParser_test.ml
index 2cdb3bb..becf9ab 100755
--- a/tests/odf/odf_ExpressionParser_test.ml
+++ b/tests/odf/odf_ExpressionParser_test.ml
@@ -13,6 +13,13 @@ let _msg ~(expected:ScTypes.expression) ~(result:ScTypes.expression) =
       (UTF8.raw_encode @@ UTF8.Buffer.contents b2)

 

 

+

+let build_num value = ScTypes.Num (

+  ScTypes.Number,

+  DataType.Num.of_num @@ Num.num_of_int value

+)

+

+

 let test_formula ctx = begin

 

   let test1 = "of:=CONCATENATE(SUM([.F16:.AJ16]);\"/\";8*NETWORKDAYS([.F6]; [.F6]+(ORG.OPENOFFICE.DAYSINMONTH([.F6])-1)))" in

@@ -27,7 +34,7 @@ let test_formula ctx = begin
         Ref (Range (((6, 16), (false, false)), (((36, 16), (false, false)))))]);

       Value (Str (u"/"));

       Call(u"*", [

-        Value (Num ((Num.num_of_int 8, Some (u"8"))));

+        Value (build_num 8);

         Call(u"NETWORKDAYS", [

           Ref (Cell ((6, 6), (false, false)));

           Call(u"+", [

@@ -36,7 +43,7 @@ let test_formula ctx = begin
               Call( u"-", [

                 Call(u"ORG.OPENOFFICE.DAYSINMONTH", [

                   Ref (Cell ((6, 6), (false, false)))]);

-                Value (Num ((Num.num_of_int 1, Some (u"1"))));

+                Value (build_num 1);

               ]))])])])])) in

 

   assert_equal

diff --git a/tests/sheet_test.ml b/tests/sheet_test.ml
index 71f5749..084118f 100755
--- a/tests/sheet_test.ml
+++ b/tests/sheet_test.ml
@@ -16,6 +16,11 @@ let _msg ~expected ~result = begin
     (get_string result)
 end
 
+let build_num value = ScTypes.Num (
+  ScTypes.Number,
+  DataType.Num.of_num @@ Num.num_of_int value
+)
+
 (** Test a simple references between two cells *)
 let test_create_ref_1 ctx = begin
 
@@ -24,7 +29,7 @@ let test_create_ref_1 ctx = begin
        |> snd |> Sheet.Raw.add (0,0) @@ Expression.load @@ u"=C3"
        |> snd in
   let result = (Sheet.Raw.get_value (0, 0) s) in
-  let expected = Some (ScTypes.Result (ScTypes.Num (Num.num_of_int (-1), None))) in
+  let expected = Some (ScTypes.Result (build_num (-1))) in
 
   assert_equal
     ~msg:(_msg ~expected ~result)
@@ -42,7 +47,7 @@ let test_create_ref_2 ctx = begin
 
 
   let result = (Sheet.Raw.get_value (2, 2) s) in
-  let expected = Some (ScTypes.Result (ScTypes.Num (Num.num_of_int 123, None))) in
+  let expected = Some (ScTypes.Result (build_num 123)) in
 
   assert_equal
     ~msg:(_msg ~expected ~result)
@@ -96,7 +101,7 @@ let test_check_cycle3 ctx = begin
       |> snd in
   let result = (Sheet.Raw.get_value (1, 3) s) in
   (* A3 = A1 + A1 = 4 *)
-  let expected = Some (ScTypes.Result (ScTypes.Num (Num.num_of_int 4, None))) in
+  let expected = Some (ScTypes.Result (build_num 4)) in
 
   assert_equal
     ~msg:(_msg ~expected ~result)
diff --git a/tools.ml b/tools.ml
index 0954be1..45c9bab 100755
--- a/tools.ml
+++ b/tools.ml
@@ -281,12 +281,6 @@ module NCurses = struct
 
 end
 
-module Date = struct
-
-  include Date
-
-end
-
 let try_finally f except =
   try let res = f () in
     except ();