More expressive on the ast/compiler

Author: davesnx

source/Ast.ml

@@ -9,15 +9,15 @@ type builtin = Add | Abs [@@deriving show { with_path = false }]
 
 type op =
   | Add
-  | Sub
-  | Mult
-  | Div
-  | Eq
-  | Neq
-  | Gt (* > *)
-  | St (* < *)
-  | Ge (* >=*)
-  | Se (* <= *)
+  | Subtract
+  | Multiply
+  | Divide
+  | Equal
+  | Not_equal
+  | Greater_than
+  | Less_than
+  | Greater_than_or_equal
+  | Less_than_or_equal
   | And
   | Or
 [@@deriving show { with_path = false }]

source/Compiler.ml

@@ -138,14 +138,14 @@ module Operators = struct
   let lte = compare "<=" ( <= )
   let and_ = condition "and" ( && )
   let or_ = condition "or" ( || )
-  let eq l r = Output.return (`Bool (l = r))
-  let notEq l r = Output.return (`Bool (l <> r))
+  let equal l r = Output.return (`Bool (l = r))
+  let not_equal l r = Output.return (`Bool (l <> r))
 
   (* Since + is used to concat strings, objects, lists, we don't use apply_op *)
   let add = add "+"
-  let sub = apply_op "-" (fun l r -> l -. r)
-  let mult = apply_op "*" (fun l r -> l *. r)
-  let div = apply_op "/" (fun l r -> l /. r)
+  let subtract = apply_op "-" (fun l r -> l -. r)
+  let multiply = apply_op "*" (fun l r -> l *. r)
+  let divide = apply_op "/" (fun l r -> l /. r)
 end
 
 let keys (json : Json.t) =
@@ -341,15 +341,15 @@ let rec compile expression json : (Json.t list, string) result =
   | Operation (left, op, right) -> (
       match op with
       | Add -> operation left right Operators.add json
-      | Sub -> operation left right Operators.sub json
-      | Mult -> operation left right Operators.mult json
-      | Div -> operation left right Operators.div json
-      | Gt -> operation left right Operators.gt json
-      | Ge -> operation left right Operators.gte json
-      | St -> operation left right Operators.lt json
-      | Se -> operation left right Operators.lte json
-      | Eq -> operation left right Operators.eq json
-      | Neq -> operation left right Operators.notEq json
+      | Subtract -> operation left right Operators.subtract json
+      | Multiply -> operation left right Operators.multiply json
+      | Divide -> operation left right Operators.divide json
+      | Greater_than -> operation left right Operators.gt json
+      | Greater_than_or_equal -> operation left right Operators.gte json
+      | Less_than -> operation left right Operators.lt json
+      | Less_than_or_equal -> operation left right Operators.lte json
+      | Equal -> operation left right Operators.equal json
+      | Not_equal -> operation left right Operators.not_equal json
       | And -> operation left right Operators.and_ json
       | Or -> operation left right Operators.or_ json)
   | Literal literal -> (

source/Parser.mly

@@ -83,16 +83,16 @@ sequence_expr:
     { e }
 
 %inline operator:
-  | SUB {Sub}
+  | SUB {Subtract}
   | ADD {Add}
-  | MULT {Mult}
-  | DIV {Div}
-  | EQUAL {Eq}
-  | NOT_EQUAL {Neq}
-  | GREATER {Gt}
-  | LOWER {St}
-  | GREATER_EQUAL {Ge}
-  | LOWER_EQUAL {Se}
+  | MULT {Multiply}
+  | DIV {Divide}
+  | EQUAL {Equal}
+  | NOT_EQUAL {Not_equal}
+  | GREATER {Greater_than}
+  | LOWER {Less_than}
+  | GREATER_EQUAL {Greater_than_or_equal}
+  | LOWER_EQUAL {Less_than_or_equal}
   | AND {And}
   | OR {Or}
 

test/Test_parse.ml

@@ -44,7 +44,7 @@ let tests =
       (Operation
          ( Literal (Number 1.),
            Add,
-           Operation (Literal (Number 2.), Mult, Literal (Number 3.)) ));
+           Operation (Literal (Number 2.), Multiply, Literal (Number 3.)) ));
     case "[1, 2]" (List [ Literal (Number 1.); Literal (Number 2.) ]);
     case "select(true)" (Select (Literal (Bool true)));
     case "[1][0]" (Pipe (List [ Literal (Number 1.) ], Index 0));