tests/typeable_tests.ml

   1 (*pp deriving *)
   2
   3 type t1 = F deriving (Typeable)
   4 type t2 = F deriving (Typeable)
   5
   6 let eq_types = Typeable.TypeRep.eq
   7
   8 let _ =
   9   begin
  10     assert (eq_types
  11                    (Typeable_t1.type_rep ())
  12                    (Typeable_t1.type_rep ()));
  13     assert (eq_types
  14               (Typeable_t2.type_rep ())
  15               (Typeable_t2.type_rep ()));
  16     assert (not (eq_types
  17                    (Typeable_t1.type_rep ())
  18                    (Typeable_t2.type_rep ())));
  19     assert (not (eq_types
  20                    (Typeable_t2.type_rep ())
  21                    (Typeable_t1.type_rep ())));
  22   end
  23
  24 type t3 = int deriving (Typeable)
  25
  26 let _ =
  27   begin
  28     assert (eq_types
  29               (Typeable.Typeable_int.type_rep ())
  30               (Typeable_t3.type_rep ()));
  31   end
  32
  33
  34 type t4 = [`T of int] deriving (Typeable)
  35 type t5 = [`T of t3] deriving (Typeable)
  36
  37 let _ =
  38   begin
  39     assert (eq_types
  40               (Typeable_t4.type_rep ())
  41               (Typeable_t5.type_rep ()));
  42   end
  43
  44 type t6 = [`T of t5]
  45     deriving (Typeable)
  46
  47 let _ =
  48   begin
  49     assert (not (eq_types
  50                    (Typeable_t5.type_rep ())
  51                    (Typeable_t6.type_rep ())));
  52
  53   end
  54
  55 type t7 = [`T of t6]
  56     deriving (Typeable)
  57
  58 let _ =
  59   begin
  60     assert (not (eq_types
  61                    (Typeable_t6.type_rep ())
  62                    (Typeable_t7.type_rep ())));
  63   end
  64
  65
  66 type t8 = [`A | `B] deriving (Typeable)
  67 type t9 = [`B | `A] deriving (Typeable)
  68
  69 let _ =
  70   begin
  71     assert (eq_types
  72               (Typeable_t8.type_rep ())
  73               (Typeable_t9.type_rep ()));
  74   end
  75
  76
  77 type ('a,'r) openr = [`Nil | `Cons of 'a * 'r]
  78  deriving (Typeable)
  79 type 'a closedr = [`Nil | `Cons of 'a * 'a closedr]
  80  deriving (Typeable)
  81 type l1 = (int, l1) openr
  82 and l2 = int closedr deriving (Typeable)
  83
  84 let _ =
  85   begin
  86     assert (eq_types
  87               (Typeable_l1.type_rep ())
  88               (Typeable_l1.type_rep ()));
  89   end
  90
  91 type nil = [`Nil] deriving (Typeable)
  92 type t10 = ([nil| `Cons of int * 'a ] as 'a) list
  93     deriving (Typeable)
  94 type t11 = l2 list deriving (Typeable)
  95
  96 let _ =
  97   begin
  98     assert
  99       (eq_types
 100          (Typeable_t10.type_rep ())
 101          (Typeable_t11.type_rep ()));
 102   end