From 0b6f0e03be19a14aad64e7dc285198a865abde75 Mon Sep 17 00:00:00 2001 From: Galfour Date: Thu, 23 May 2019 15:43:18 +0000 Subject: [PATCH] add basic doc in `operators/operators.ml` --- src/operators/helpers.ml | 111 +++++++++++++++++++++++ src/operators/operators.ml | 178 ++++++++++++++----------------------- 2 files changed, 179 insertions(+), 110 deletions(-) create mode 100644 src/operators/helpers.ml diff --git a/src/operators/helpers.ml b/src/operators/helpers.ml new file mode 100644 index 000000000..a04f566f5 --- /dev/null +++ b/src/operators/helpers.ml @@ -0,0 +1,111 @@ +module Typer = struct + + open Trace + open Ast_typed + + module Errors = struct + let wrong_param_number = fun name expected got -> + let title () = "wrong number of params" in + let full () = Format.asprintf "constant name: %s\nexpected: %d\ngot: %d\n" + name expected (List.length got) in + error title full + end + + + type type_result = string * type_value + type typer' = type_value list -> type_value option -> type_result result + type typer = string * typer' + + let typer'_0 : name -> (type_value option -> type_value result) -> typer' = fun s f lst tv_opt -> + match lst with + | [] -> ( + let%bind tv' = f tv_opt in + ok (s , tv') + ) + | _ -> fail @@ Errors.wrong_param_number s 0 lst + let typer_0 name f : typer = (name , typer'_0 name f) + + let typer'_1 : name -> (type_value -> type_value result) -> typer' = fun s f lst _ -> + match lst with + | [ a ] -> ( + let%bind tv' = f a in + ok (s , tv') + ) + | _ -> fail @@ Errors.wrong_param_number s 1 lst + let typer_1 name f : typer = (name , typer'_1 name f) + + let typer'_1_opt : name -> (type_value -> type_value option -> type_value result) -> typer' = fun s f lst tv_opt -> + match lst with + | [ a ] -> ( + let%bind tv' = f a tv_opt in + ok (s , tv') + ) + | _ -> fail @@ Errors.wrong_param_number s 1 lst + let typer_1_opt name f : typer = (name , typer'_1_opt name f) + + let typer'_2 : name -> (type_value -> type_value -> type_value result) -> typer' = fun s f lst _ -> + match lst with + | [ a ; b ] -> ( + let%bind tv' = f a b in + ok (s , tv') + ) + | _ -> fail @@ Errors.wrong_param_number s 2 lst + let typer_2 name f : typer = (name , typer'_2 name f) + + let typer'_3 : name -> (type_value -> type_value -> type_value -> type_value result) -> typer' = fun s f lst _ -> + match lst with + | [ a ; b ; c ] -> ( + let%bind tv' = f a b c in + ok (s , tv') + ) + | _ -> fail @@ Errors.wrong_param_number s 3 lst + let typer_3 name f : typer = (name , typer'_3 name f) + + let constant name cst = typer_0 name (fun _ -> ok cst) + + open Combinators + + let eq_1 a cst = type_value_eq (a , cst) + let eq_2 (a , b) cst = type_value_eq (a , cst) && type_value_eq (b , cst) + + let comparator : string -> typer = fun s -> typer_2 s @@ fun a b -> + let%bind () = + trace_strong (simple_error "Types a and b aren't comparable") @@ + Assert.assert_true @@ + List.exists (eq_2 (a , b)) [ + t_int () ; + t_nat () ; + t_tez () ; + t_string () ; + t_bytes () ; + t_address () ; + ] in + ok @@ t_bool () + + let boolean_operator_2 : string -> typer = fun s -> typer_2 s @@ fun a b -> + let%bind () = + trace_strong (simple_error "A isn't of type bool") @@ + Assert.assert_true @@ + type_value_eq (t_bool () , a) in + let%bind () = + trace_strong (simple_error "B isn't of type bool") @@ + Assert.assert_true @@ + type_value_eq (t_bool () , b) in + ok @@ t_bool () + +end + +module Compiler = struct + + open Tezos_utils.Michelson + + type predicate = + | Constant of michelson + | Unary of michelson + | Binary of michelson + | Ternary of michelson + let simple_constant c = Constant c + let simple_unary c = Unary c + let simple_binary c = Binary c + let simple_ternary c = Ternary c +end diff --git a/src/operators/operators.ml b/src/operators/operators.ml index 2674bbc99..6bec03b63 100644 --- a/src/operators/operators.ml +++ b/src/operators/operators.ml @@ -1,7 +1,37 @@ open Trace +(* + This file is used throughout the pipeline. Its idea is to add a unique place + that you have to modify when you add a new operator/constant to the language. + + This file mirrors the LIGO pipeline, starting with Simplify, then Typer and + ending with Compiler. Usually, when adding a new operator, you'll have to add + a new constructor at all those places. +*) + module Simplify = struct + (* + Each front-end has its owns constants. + + Constants are special names that have their own case in the AST. E_constant + for regular constants, and T_constant for type constants. Both types are + defined in `Ast_simplified/types.ml`. + For instance, "2 + 2" in Pascaligo is translated to `E_constant ("ADD" , [ + E_literal (Literal_int 2) ; + E_literal (Literal_int 2) ; + ])`. + + They are used to represent what can't expressed in the languages: + - Primitives. Like "int", "string", "unit" for types. Or "+" for values. + - Tezos specific stuff. Like "operation" for types. Or "source" for values. + - What can't be represented in the language yet. Like "list" or "List.fold". + + Each constant is expressed as a pair: + - The left-hand-side is the reserved name in the given front-end. + - The right-hand-side is the name that will be used in the AST. + *) + let type_constants = [ ("unit" , "unit") ; ("string" , "string") ; @@ -58,99 +88,33 @@ module Simplify = struct end module Typer = struct + (* + Each constant has its own type. + LIGO's type-system is currently too + weak to express the constant's type. For instance: + - "ADD" has a special kind of type of polymorphism. If "ADD" gets two `int`s, + it will return an `int`. If it gets two `nat`s, it will return a `nat`. + Regular polymorphism wouldn't work because "ADD" only accepts `int`s or + `nat`s. + - "NONE" (from Some/None) requires an annotation. + + Instead of a LIGO type, constant types are representend as functions. These + functions take as parameters: + - The list of types of the arguments of the constants. When typing `2 + 2`, + the types might be `[ int ; int ]`. + - The expected type of the whole expression. It is optional. When typing + `[] : list(operation)`, it will be `Some ( list (operation) )`. When + typing `2 + 2` (with no additional context), it will be `None`. + The output is the type of the whole expression. An error is returned through + the Trace monad if it doesn't type-check (`"toto" + 42`). + + Various helpers are defined and explaines in `Helpers.Typer`. + *) + + open Helpers.Typer open Ast_typed - module Errors = struct - let wrong_param_number = fun name expected got -> - let title () = "wrong number of params" in - let full () = Format.asprintf "constant name: %s\nexpected: %d\ngot: %d\n" - name expected (List.length got) in - error title full - end - - - type type_result = string * type_value - type typer' = type_value list -> type_value option -> type_result result - type typer = string * typer' - - let typer'_0 : name -> (type_value option -> type_value result) -> typer' = fun s f lst tv_opt -> - match lst with - | [] -> ( - let%bind tv' = f tv_opt in - ok (s , tv') - ) - | _ -> fail @@ Errors.wrong_param_number s 0 lst - let typer_0 name f : typer = (name , typer'_0 name f) - - let typer'_1 : name -> (type_value -> type_value result) -> typer' = fun s f lst _ -> - match lst with - | [ a ] -> ( - let%bind tv' = f a in - ok (s , tv') - ) - | _ -> fail @@ Errors.wrong_param_number s 1 lst - let typer_1 name f : typer = (name , typer'_1 name f) - - let typer'_1_opt : name -> (type_value -> type_value option -> type_value result) -> typer' = fun s f lst tv_opt -> - match lst with - | [ a ] -> ( - let%bind tv' = f a tv_opt in - ok (s , tv') - ) - | _ -> fail @@ Errors.wrong_param_number s 1 lst - let typer_1_opt name f : typer = (name , typer'_1_opt name f) - - let typer'_2 : name -> (type_value -> type_value -> type_value result) -> typer' = fun s f lst _ -> - match lst with - | [ a ; b ] -> ( - let%bind tv' = f a b in - ok (s , tv') - ) - | _ -> fail @@ Errors.wrong_param_number s 2 lst - let typer_2 name f : typer = (name , typer'_2 name f) - - let typer'_3 : name -> (type_value -> type_value -> type_value -> type_value result) -> typer' = fun s f lst _ -> - match lst with - | [ a ; b ; c ] -> ( - let%bind tv' = f a b c in - ok (s , tv') - ) - | _ -> fail @@ Errors.wrong_param_number s 3 lst - let typer_3 name f : typer = (name , typer'_3 name f) - - let constant name cst = typer_0 name (fun _ -> ok cst) - - open Combinators - - let eq_1 a cst = type_value_eq (a , cst) - let eq_2 (a , b) cst = type_value_eq (a , cst) && type_value_eq (b , cst) - - let comparator : string -> typer = fun s -> typer_2 s @@ fun a b -> - let%bind () = - trace_strong (simple_error "Types a and b aren't comparable") @@ - Assert.assert_true @@ - List.exists (eq_2 (a , b)) [ - t_int () ; - t_nat () ; - t_tez () ; - t_string () ; - t_bytes () ; - t_address () ; - ] in - ok @@ t_bool () - - let boolean_operator_2 : string -> typer = fun s -> typer_2 s @@ fun a b -> - let%bind () = - trace_strong (simple_error "A isn't of type bool") @@ - Assert.assert_true @@ - type_value_eq (t_bool () , a) in - let%bind () = - trace_strong (simple_error "B isn't of type bool") @@ - Assert.assert_true @@ - type_value_eq (t_bool () , b) in - ok @@ t_bool () - let none = typer_0 "NONE" @@ fun tv_opt -> match tv_opt with | None -> simple_fail "untyped NONE" @@ -262,12 +226,7 @@ module Typer = struct then ok @@ t_int () else simple_fail "Adding with wrong types" - - - let constant_typers = - let typer_to_kv : typer -> (string * _) = fun x -> x in - Map.String.of_list - @@ List.map typer_to_kv [ + let constant_typers = Map.String.of_list [ add ; times ; div ; @@ -303,23 +262,22 @@ module Typer = struct end module Compiler = struct + (* + Most constants pass through the Transpiler unchanged. So they need to be + compiled down to Michelson. This is the last step. - module Michelson = Tezos_utils.Michelson - open Michelson + When compiling the constant, we need to provide its arity (through the type + predicate, defined in `Helpers.Compiler`, and its michelson code. + In the case of an n-ary constant, we assume that the stack has the form: + `x1 :: x2 :: x3 ... :: xn :: _`. - type predicate = - | Constant of michelson - | Unary of michelson - | Binary of michelson - | Ternary of michelson + This step requires knowledge of Michelson. Knowledge of + `Tezos_utils.Michelson` will help too, so that no Michelson has to actually + be written by hand. + *) - let simple_constant c = Constant c - - let simple_unary c = Unary c - - let simple_binary c = Binary c - - let simple_ternary c = Ternary c + include Helpers.Compiler + open Tezos_utils.Michelson let predicates = Map.String.of_list [ ("ADD" , simple_binary @@ prim I_ADD) ;