feat(compiler): Rational number type (#1603)

* feat(compiler): Rational number type

* added numerator, denominator functions

* updated tests

* updated docs

Author: alex-snezhko

compiler/src/codegen/transl_anf.re

@@ -527,6 +527,7 @@ let compile_const = (c: Asttypes.constant) =>
   | Const_string(_) => failwith("compile_const: Const_string post-ANF")
   | Const_char(_) => failwith("compile_const: Const_char post-ANF")
   | Const_bigint(_) => failwith("compile_const: Const_bigint post-ANF")
+  | Const_rational(_) => failwith("compile_const: Const_rational post-ANF")
   | Const_int32(i32) => MConstI32(i32)
   | Const_int64(i64) => MConstI64(i64)
   | Const_uint32(u32) => MConstU32(u32)

compiler/src/middle_end/linearize.re

@@ -182,6 +182,12 @@ let transl_const =
         [BLet(tmp, Comp.number(Const_number_bigint(data)), Nonglobal)]
       ),
     )
+  | Const_rational(data) =>
+    Right(
+      with_bind("rational", tmp =>
+        [BLet(tmp, Comp.number(Const_number_rational(data)), Nonglobal)]
+      ),
+    )
   | Const_int32(i) =>
     Right(with_bind("int32", tmp => [BLet(tmp, Comp.int32(i), Nonglobal)]))
   | Const_int64(i) =>

compiler/src/middle_end/matchcomp.re

@@ -539,6 +539,7 @@ let equality_type =
   | Const_uint32(_)
   | Const_uint64(_)
   | Const_bigint(_)
+  | Const_rational(_)
   | Const_float32(_)
   | Const_float64(_)
   | Const_bytes(_)

compiler/src/parsing/ast_helper.re

@@ -72,6 +72,14 @@ module Constant = {
   let wasmf32 = f => PConstWasmF32(f);
   let wasmf64 = f => PConstWasmF64(f);
   let bigint = i => PConstBigInt(i);
+  let rational = r => {
+    let (n, d) =
+      switch (String.split_on_char('/', r)) {
+      | [n, d] => (n, d)
+      | _ => failwith("Impossible: rational literal without forward slash")
+      };
+    PConstRational(n, d);
+  };
   let bool = b => PConstBool(b);
   let void = PConstVoid;
 };

compiler/src/parsing/ast_helper.rei

@@ -48,6 +48,7 @@ module Constant: {
   let wasmf32: string => constant;
   let wasmf64: string => constant;
   let bigint: string => constant;
+  let rational: string => constant;
   let bool: bool => constant;
   let void: constant;
 };

compiler/src/parsing/asttypes.re

@@ -26,6 +26,15 @@ type bigint_data = {
   bigint_rep: string,
 };
 
+[@deriving (sexp, yojson)]
+type rational_data = {
+  rational_negative: bool,
+  rational_num_limbs: array(int64),
+  rational_den_limbs: array(int64),
+  rational_num_rep: string,
+  rational_den_rep: string,
+};
+
 [@deriving (sexp, yojson)]
 type constant =
   | Const_number(number_type)
@@ -43,20 +52,15 @@ type constant =
   | Const_wasmf32(float)
   | Const_wasmf64(float)
   | Const_bigint(bigint_data)
+  | Const_rational(rational_data)
   | Const_bool(bool)
   | Const_void
 
 [@deriving (sexp, yojson)]
 and number_type =
   | Const_number_int(int64)
   | Const_number_float(float)
-  | Const_number_rational({
-      rational_negative: bool,
-      rational_num_limbs: array(int64),
-      rational_den_limbs: array(int64),
-      rational_num_rep: string,
-      rational_den_rep: string,
-    })
+  | Const_number_rational(rational_data)
   | Const_number_bigint(bigint_data);
 
 /** Marker for exported/nonexported let bindings */

compiler/src/parsing/lexer.re

@@ -253,6 +253,8 @@ let rec token = lexbuf => {
   | (unsigned_float, 'w') => positioned(WASMF32(sub_lexeme(lexbuf, 0, -1)))
   | (unsigned_float, 'W') => positioned(WASMF64(sub_lexeme(lexbuf, 0, -1)))
   | (unsigned_int, 't') => positioned(BIGINT(sub_lexeme(lexbuf, 0, -1)))
+  | (unsigned_int, '/', Opt('-'), unsigned_int, 'r') =>
+    positioned(RATIONAL(sub_lexeme(lexbuf, 0, -1)))
   | unsigned_int => positioned(NUMBER_INT(Sedlexing.Utf8.lexeme(lexbuf)))
   | "primitive" => positioned(PRIMITIVE)
   | "foreign" => positioned(FOREIGN)

compiler/src/parsing/parser.mly

@@ -12,6 +12,7 @@ module Grain_parsing = struct end
 %}
 
 
+%token <string> RATIONAL
 %token <string> NUMBER_INT NUMBER_FLOAT
 %token <string> INT32 INT64 UINT32 UINT64 FLOAT32 FLOAT64 BIGINT
 %token <string> WASMI32 WASMI64 WASMF32 WASMF64
@@ -208,6 +209,7 @@ const:
   | DASH? WASMF32 { Constant.wasmf32 (if Option.is_some $1 then "-" ^ $2 else $2), $sloc }
   | DASH? WASMF64 { Constant.wasmf64 (if Option.is_some $1 then "-" ^ $2 else $2), $sloc }
   | DASH? BIGINT { Constant.bigint (if Option.is_some $1 then "-" ^ $2 else $2), $sloc }
+  | DASH? RATIONAL { Constant.rational (if Option.is_some $1 then "-" ^ $2 else $2), $sloc }
   | TRUE { Constant.bool true, $loc }
   | FALSE { Constant.bool false, $loc }
   | VOID { Constant.void, $loc }

compiler/src/parsing/parsetree.re

@@ -130,6 +130,7 @@ type constant =
   | PConstWasmF32(string)
   | PConstWasmF64(string)
   | PConstBigInt(string)
+  | PConstRational(string, string)
   | PConstBool(bool)
   | PConstVoid
   | PConstBytes(string)

compiler/src/parsing/well_formedness.re

@@ -255,15 +255,21 @@ let no_letrec_mut = (errs, super) => {
 let no_zero_denominator_rational = (errs, super) => {
   let enter_expression = ({pexp_desc: desc, pexp_loc: loc} as e) => {
     switch (desc) {
-    | PExpConstant(PConstNumber(PConstNumberRational(_, d))) when d == "0" =>
+    | PExpConstant(
+        PConstNumber(PConstNumberRational(_, d)) | PConstRational(_, d),
+      )
+        when d == "0" =>
       errs := [RationalZeroDenominator(loc), ...errs^]
     | _ => ()
     };
     super.enter_expression(e);
   };
   let enter_pattern = ({ppat_desc: desc, ppat_loc: loc} as p) => {
     switch (desc) {
-    | PPatConstant(PConstNumber(PConstNumberRational(_, d))) when d == "0" =>
+    | PPatConstant(
+        PConstNumber(PConstNumberRational(_, d)) | PConstRational(_, d),
+      )
+        when d == "0" =>
       errs := [RationalZeroDenominator(loc), ...errs^]
     | _ => ()
     };