(** All the types used in the spreadsheet. *)

(** This module describe the most basic type use in the spreadsheet : every content is,

- either a ['a t]
- either an expression which result to one ['a t]

*)
module Type : sig

  type 'a t

  (** Create a new number *)
  val number: DataType.Num.t -> DataType.Num.t t

  (** Create a new string *)
  val string: DataType.String.t -> DataType.String.t t

  (** Create a new boolean *)
  val boolean: DataType.Bool.t -> DataType.Bool.t t

  (** Create a new date *)
  val date: DataType.Num.t -> DataType.Num.t t

  val (=) : 'a t -> 'b t -> bool

  (** Evaluate a type and get the result *)
  module Eval(T:Sym_type.SYM_TYPE): sig

    val eval: 'a t -> 'a T.obs

  end

end

(** A reference to another cell.

The reference can be a single cell (ie : A$1) or a range.

*)
module Refs : sig

  type t 

  val cell : Cell.t -> t

  val range : Cell.t -> Cell.t -> t

  val shift: (int * int) -> t -> t

  (** Evaluate a reference and get the result *)
  module Eval(R:Sym_ref.SYM_REF): sig

    val eval: t -> 'a R.obs

  end

end

module Expr : sig

  type ident = UTF8.t

  (** This is the cell content *)
  type t

  (** Declare a direct value *)
  val value: 'a Type.t -> t

  (** Declare a reference to another cell *)
  val ref: Refs.t -> t

  (** Declare a call to a 0 arg function *)
  val call0: ident -> t

  (** Declare a call to a 1 arg function *)
  val call1 : ident -> t -> t

  (** Declare a call to a 2 arg function *)
  val call2 : ident -> t -> t -> t

  (** Declare a call to a 3 arg function *)
  val call3 : ident -> t -> t -> t -> t

  (** Declare a call to a function *)
  val callN : ident -> t list -> t

  (** An expression *)
  val expression : t -> t

  val shift_exp: (int * int) -> t -> t

  module Eval(E:Sym_expr.SYM_EXPR): sig

    val eval: t -> E.t -> E.obs

  end

end

module DataFormat : sig

  type 'a t =
    | Date: DataType.Num.t t      (* A date in julian day *)
    | Number: DataType.Num.t t    (* Number *)
    | String: DataType.String.t t (* String *)
    | Bool: DataType.Bool.t t     (* Boolean *)
  
  type formats = F : 'a t -> formats [@@unboxed]

  val default_value_for: 'a t -> 'a

  type ('a, 'b) equality = Eq : ('a, 'a) equality

  val compare_format: 'a t -> 'b t -> ('a, 'b) equality

  val priority: 'a t -> int

end

module ReturnType : sig

  (** Private type for an internal representation of return format *)
  type 'a t
  
  (** Numeric (any format) *)
  val f_num: DataType.Num.t t
  
  (** Date *)
  val f_date: DataType.Num.t t
  
  (** Number *)
  val f_number: DataType.Num.t t
  
  (** Boolean result *)
  val f_bool: DataType.Bool.t t
  
  (** String *)
  val f_string: DataType.String.t t

  val guess_format_result: 'a t -> (unit -> DataFormat.formats list) -> 'a DataFormat.t

end

module Result : sig

  (** Result from a computation *)
  type t =
    | Ok : 'a Type.t -> t
    | Error : exn -> t

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

  val show: t -> UTF8.t

end

exception Error