diff --git a/docker/distribution/generic/build.Dockerfile b/docker/distribution/generic/build.Dockerfile index ba01c043c..f6c9358e9 100644 --- a/docker/distribution/generic/build.Dockerfile +++ b/docker/distribution/generic/build.Dockerfile @@ -29,7 +29,7 @@ RUN opam update # Install ligo RUN sh scripts/install_vendors_deps.sh -RUN opam install -y . || (tail -n +1 ~/.opam/log/* ; false) +RUN opam install -y . # Use the ligo binary as a default command ENTRYPOINT [ "/home/opam/.opam/4.07/bin/ligo" ] diff --git a/gitlab-pages/docs/reference/big_map.md b/gitlab-pages/docs/reference/big_map.md new file mode 100644 index 000000000..4dd6ba3af --- /dev/null +++ b/gitlab-pages/docs/reference/big_map.md @@ -0,0 +1,268 @@ +--- +id: big-map-reference +title: Big Map +--- + +## Defining A Big Map Type + + + +```pascaligo +type move is (int * int) +type moveset is big_map (address, move) +type foo is big_map (int, int) +``` + + +```cameligo +type move = int * int +type moveset = (address, move) big_map +type foo = (int, int) big_map +``` + + +```reasonligo +type move = (int, int); +type moveset = big_map(address, move); +type foo = big_map(int, int); +``` + + + +## Creating A Map + + + + +```pascaligo +const moves: moveset = + big_map + ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address) -> (1,2); + ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) -> (0,3); + end +``` + + + +```cameligo +let moves: moveset = + Big_map.literal [ + (("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address), (1,2)); + (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), (0,3)); + ] +``` + + + +```reasonligo +let moves: moveset = + Big_map.literal ([ + ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address, (1,2)), + ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address, (0,3)), + ]); +``` + + + +## Big_map.find_opt(k: a', m: (a',b') big_map) : b' option + +Retrieve the value associated with a particular key. This version returns an option +which can either shift logic in response to a missing value or throw an error. + + + +```pascaligo +const my_balance : option(move) = + moves [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] +``` + + + +```cameligo +let my_balance : move option = + Big_map.find_opt ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves +``` + + + +```reasonligo +let my_balance : option(move) = + Big_map.find_opt("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address, moves); +``` + + +## Big_map.find(k: a', m: (a', b') big_map) : b' + +Forcefully retrieve the value associated with a particular key. If that value +doesn't exist, this function throws an error. + + + +```pascaligo +const my_balance : move = + get_force (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves); +``` + + + +```cameligo +let my_balance : move = + Big_map.find ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves +``` + + + +```reasonligo +let my_balance : move = + Big_map.find ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address, moves); +``` + + + +## Big_map.update(k: a', v: b', m: (a', b') big_map) : (a', b') big_map + +Change the value associated with a particular key, if that value doesn't already +exist add it. + + + + + +The values of a PascaLIGO big map can be updated using the ordinary +assignment syntax: + +```pascaligo + +function set_ (var m : moveset) : moveset is + block { + m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9); + } with m +``` + + + +```cameligo +let updated_map : moveset = + Big_map.update ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) (Some (4,9)) moves +``` + + + +```reasonligo +let updated_map : moveset = + Big_map.update(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some((4,9)), moves); +``` + + + +## Big_map.add(k: a', v: b', m: (a', b') big_map) : (a', b') big_map + +Add a key and its associated value to the big map. + + + + +```pascaligo +function set_ (var n : int ; var m : foo) : foo is block { + m[23] := n ; +} with m +``` + + +```cameligo +let add (n,m : int * foo) : foo = Big_map.add 23 n m +``` + + +```reasonligo +let add = ((n,m): (int, foo)): foo => Big_map.add(23, n, m); +``` + + + +## Big_map.remove(k: a', m: (a', b') big_map) : (a', b') big_map + +Remove a key and its associated value from the big map. + + + + +```pascaligo +function rm (var m : foo) : foo is block { + remove 42 from map m; +} with m +``` + + +```cameligo +let rm (m : foo) : foo = Big_map.remove 42 m +``` + + +```reasonligo +let rm = (m: foo): foo => Big_map.remove(42, m); +``` + + + +## Big_map.literal(key_value_pair_list: (a', b') list) : (a', b') big_map + +Constructs a big map from a list of key-value pair tuples. + + + + +```pascaligo +const moves: moveset = + big_map + ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address) -> (1,2); + ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) -> (0,3); + end +``` + + + +```cameligo +let moves: moveset = + Big_map.literal [ + (("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address), (1,2)); + (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), (0,3)); + ] +``` + + + +```reasonligo +let moves: moveset = + Big_map.literal ([ + ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address, (1,2)), + ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address, (0,3)), + ]); +``` + + + + +## Big_map.empty() : (a', b') big_map + +Create an empty big map. + + + + +```pascaligo +const empty_big_map : big_map(int,int) = big_map end +``` + + +```cameligo +let empty_map : foo = Big_map.empty +``` + + +```reasonligo +let empty_map: foo = Big_map.empty; +``` + + + diff --git a/scripts/build_docker_image.sh b/scripts/build_docker_image.sh index f342b424f..260a530c7 100755 --- a/scripts/build_docker_image.sh +++ b/scripts/build_docker_image.sh @@ -1,4 +1,3 @@ #!/bin/sh set -e -set -x -docker build -t "${LIGO_REGISTRY_IMAGE_BUILD:-ligolang/ligo}:next" -f ./docker/distribution/debian/distribute.Dockerfile . +docker build -t "${LIGO_REGISTRY_IMAGE_BUILD:-ligolang/ligo}:next" -f ./docker/distribution/debian/distribute.Dockerfile . \ No newline at end of file diff --git a/scripts/build_ligo_local.sh b/scripts/build_ligo_local.sh index fb556805a..b78e4ffd6 100755 --- a/scripts/build_ligo_local.sh +++ b/scripts/build_ligo_local.sh @@ -1,6 +1,5 @@ #!/bin/sh set -e -set -x eval $(opam config env) dune build -p ligo diff --git a/scripts/distribution/generic/build.sh b/scripts/distribution/generic/build.sh index 968f55a21..49aba15e1 100755 --- a/scripts/distribution/generic/build.sh +++ b/scripts/distribution/generic/build.sh @@ -1,6 +1,4 @@ #!/bin/sh -set -e -set -x dockerfile_name="build" # Generic dockerfile diff --git a/scripts/distribution/generic/package.sh b/scripts/distribution/generic/package.sh index d9d047e6d..79be37d41 100755 --- a/scripts/distribution/generic/package.sh +++ b/scripts/distribution/generic/package.sh @@ -1,6 +1,4 @@ #!/bin/sh -set -e -set -x dockerfile_name="package" dockerfile="" diff --git a/scripts/distribution/generic/parameters.sh b/scripts/distribution/generic/parameters.sh index 2241b9fb0..3899711d8 100644 --- a/scripts/distribution/generic/parameters.sh +++ b/scripts/distribution/generic/parameters.sh @@ -1,15 +1,11 @@ -#!/bin/sh -set -e -set -x - # This script accepts three arguments, os family, os and its version, # which are subsequently used to fetch the respective docker # image from the ocaml/infrastructure project. # # https://github.com/ocaml/infrastructure/wiki/Containers#selecting-linux-distributions -target_os_family="$1" -target_os="$2" -target_os_version="$3" +target_os_family=$1 +target_os=$2 +target_os_version=$3 # Variables configured at the CI level dist="$LIGO_DIST_DIR" @@ -33,4 +29,4 @@ fi target_os_specific_dockerfile="./docker/distribution/$target_os_family/$target_os/$dockerfile_name.Dockerfile" if test -f "$target_os_specific_dockerfile"; then dockerfile="$target_os_specific_dockerfile" -fi +fi \ No newline at end of file diff --git a/scripts/install_build_environment.sh b/scripts/install_build_environment.sh index 628235e70..0dd33f068 100755 --- a/scripts/install_build_environment.sh +++ b/scripts/install_build_environment.sh @@ -22,7 +22,6 @@ echo "Installing dependencies.." if [ -n "`uname -a | grep -i arch`" ] then sudo pacman -Sy --noconfirm \ - python \ make \ m4 \ gcc \ @@ -35,8 +34,6 @@ fi if [ -n "`uname -a | grep -i ubuntu`" ] then sudo apt-get install -y make \ - python3 \ - make \ m4 \ gcc \ patch \ diff --git a/scripts/install_native_dependencies.sh b/scripts/install_native_dependencies.sh index f12e76cb2..2a0e56903 100755 --- a/scripts/install_native_dependencies.sh +++ b/scripts/install_native_dependencies.sh @@ -1,13 +1,11 @@ #!/bin/sh set -e -set -x . /etc/os-release if [ $ID = arch ] then pacman -Sy sudo pacman -S --noconfirm \ - python \ libevdev \ perl \ pkg-config \ @@ -22,7 +20,6 @@ then else apt-get update -qq apt-get -y -qq install \ - python3 \ libev-dev \ perl \ pkg-config \ diff --git a/scripts/install_vendors_deps.sh b/scripts/install_vendors_deps.sh index 5c870ffdc..15f9b47d4 100755 --- a/scripts/install_vendors_deps.sh +++ b/scripts/install_vendors_deps.sh @@ -1,6 +1,5 @@ #!/bin/sh set -e -set -x # Install local dependencies opam install -y --deps-only --with-test ./ligo.opam $(find vendors -name \*.opam) diff --git a/src/passes/4-typer-old/typer.ml b/src/passes/4-typer-old/typer.ml index 7c1cd41a4..87f4b2477 100644 --- a/src/passes/4-typer-old/typer.ml +++ b/src/passes/4-typer-old/typer.ml @@ -649,6 +649,7 @@ and type_expression' : environment -> ?tv_opt:O.type_expression -> I.expression let wtype = Format.asprintf "Loops over collections expect lists, sets or maps, got type %a" O.PP.type_expression tv_col in fail @@ simple_error wtype in + let lname = lname in let e' = Environment.add_ez_binder lname input_type e in let%bind body = type_expression' ?tv_opt:(Some tv_out) e' result in let output_type = body.type_expression in diff --git a/src/stages/adt_generator/.gitignore b/src/stages/adt_generator/.gitignore deleted file mode 100644 index 9ec2ad34e..000000000 --- a/src/stages/adt_generator/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -# This is an auto-generated test file -/generated_fold.ml diff --git a/src/stages/adt_generator/README b/src/stages/adt_generator/README index 2d1b53c3d..20ecdfd43 100644 --- a/src/stages/adt_generator/README +++ b/src/stages/adt_generator/README @@ -1,6 +1,6 @@ -Build & test with: +Build with: - dune build adt_generator.exe && ../../../_build/default/src/stages/adt_generator/adt_generator.exe + dune build adt_generator.a Run with diff --git a/src/stages/adt_generator/a.ml b/src/stages/adt_generator/a.ml index 34b611dc1..f1d8b2fb1 100644 --- a/src/stages/adt_generator/a.ml +++ b/src/stages/adt_generator/a.ml @@ -1,6 +1,6 @@ type root = -| A of rootA -| B of rootB +| A of a +| B of int | C of string and a = { @@ -15,20 +15,3 @@ and ta1 = and ta2 = | Z of ta2 | W of unit - -and rootA = - a list - -and rootB = - int list - -let fold_list v state continue = - let aux = fun (lst', state) elt -> - let (elt', state) = continue elt state in - (elt' :: lst' , state) in - List.fold_left aux ([], state) v - -let fold_option v state continue = - match v with - Some x -> continue x state - | None -> None diff --git a/src/stages/adt_generator/dune b/src/stages/adt_generator/dune index d70d8647e..4a52c6088 100644 --- a/src/stages/adt_generator/dune +++ b/src/stages/adt_generator/dune @@ -1,9 +1,8 @@ (rule - (target generated_fold.ml) + (target fold.ml) (deps generator.py) - (action (with-stdout-to generated_fold.ml (run python3 ./generator.py))) -; (mode (promote (until-clean))) ; If this is uncommented, then "dune build -p ligo" can't find the file (but "dune build" can) -) + (action (with-stdout-to fold.ml (run python3 ./generator.py))) + (mode (promote (until-clean)))) ; (library ; (name adt_generator) ; (public_name ligo.adt_generator) @@ -17,8 +16,3 @@ (libraries ) ) - -(alias - (name runtest) - (action (run ./adt_generator.exe)) -) diff --git a/src/stages/adt_generator/fold.ml b/src/stages/adt_generator/fold.ml index 271974820..4e4c41357 100644 --- a/src/stages/adt_generator/fold.ml +++ b/src/stages/adt_generator/fold.ml @@ -1 +1,184 @@ -include Generated_fold +open A + +type root' = + | A' of a' + | B' of int + | C' of string +and a' = + { + a1' : ta1' ; + a2' : ta2' ; + } +and ta1' = + | X' of root' + | Y' of ta2' +and ta2' = + | Z' of ta2' + | W' of unit + +type 'state continue_fold = + { + root : root -> 'state -> (root' * 'state) ; + root_A : a -> 'state -> (a' * 'state) ; + root_B : int -> 'state -> (int * 'state) ; + root_C : string -> 'state -> (string * 'state) ; + a : a -> 'state -> (a' * 'state) ; + a_a1 : ta1 -> 'state -> (ta1' * 'state) ; + a_a2 : ta2 -> 'state -> (ta2' * 'state) ; + ta1 : ta1 -> 'state -> (ta1' * 'state) ; + ta1_X : root -> 'state -> (root' * 'state) ; + ta1_Y : ta2 -> 'state -> (ta2' * 'state) ; + ta2 : ta2 -> 'state -> (ta2' * 'state) ; + ta2_Z : ta2 -> 'state -> (ta2' * 'state) ; + ta2_W : unit -> 'state -> (unit * 'state) ; + } + +type 'state fold_config = + { + root : root -> 'state -> ('state continue_fold) -> (root' * 'state) ; + root_pre_state : root -> 'state -> 'state ; + root_post_state : root -> root' -> 'state -> 'state ; + root_A : a -> 'state -> ('state continue_fold) -> (a' * 'state) ; + root_B : int -> 'state -> ('state continue_fold) -> (int * 'state) ; + root_C : string -> 'state -> ('state continue_fold) -> (string * 'state) ; + a : a -> 'state -> ('state continue_fold) -> (a' * 'state) ; + a_pre_state : a -> 'state -> 'state ; + a_post_state : a -> a' -> 'state -> 'state ; + a_a1 : ta1 -> 'state -> ('state continue_fold) -> (ta1' * 'state) ; + a_a2 : ta2 -> 'state -> ('state continue_fold) -> (ta2' * 'state) ; + ta1 : ta1 -> 'state -> ('state continue_fold) -> (ta1' * 'state) ; + ta1_pre_state : ta1 -> 'state -> 'state ; + ta1_post_state : ta1 -> ta1' -> 'state -> 'state ; + ta1_X : root -> 'state -> ('state continue_fold) -> (root' * 'state) ; + ta1_Y : ta2 -> 'state -> ('state continue_fold) -> (ta2' * 'state) ; + ta2 : ta2 -> 'state -> ('state continue_fold) -> (ta2' * 'state) ; + ta2_pre_state : ta2 -> 'state -> 'state ; + ta2_post_state : ta2 -> ta2' -> 'state -> 'state ; + ta2_Z : ta2 -> 'state -> ('state continue_fold) -> (ta2' * 'state) ; + ta2_W : unit -> 'state -> ('state continue_fold) -> (unit * 'state) ; + } + +(* Curries the "visitor" argument to the folds (non-customizable traversal functions). *) +let rec mk_continue_fold : type state . state fold_config -> state continue_fold = fun visitor -> + { + root = fold_root visitor ; + root_A = fold_root_A visitor ; + root_B = fold_root_B visitor ; + root_C = fold_root_C visitor ; + a = fold_a visitor ; + a_a1 = fold_a_a1 visitor ; + a_a2 = fold_a_a2 visitor ; + ta1 = fold_ta1 visitor ; + ta1_X = fold_ta1_X visitor ; + ta1_Y = fold_ta1_Y visitor ; + ta2 = fold_ta2 visitor ; + ta2_Z = fold_ta2_Z visitor ; + ta2_W = fold_ta2_W visitor ; +} + +and fold_root : type state . state fold_config -> root -> state -> (root' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + let state = visitor.root_pre_state x state in + let (new_x, state) = visitor.root x state continue_fold in + let state = visitor.root_post_state x new_x state in + (new_x, state) + +and fold_root_A : type state . state fold_config -> a -> state -> (a' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.root_A x state continue_fold + +and fold_root_B : type state . state fold_config -> int -> state -> (int * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.root_B x state continue_fold + +and fold_root_C : type state . state fold_config -> string -> state -> (string * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.root_C x state continue_fold + +and fold_a : type state . state fold_config -> a -> state -> (a' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + let state = visitor.a_pre_state x state in + let (new_x, state) = visitor.a x state continue_fold in + let state = visitor.a_post_state x new_x state in + (new_x, state) + +and fold_a_a1 : type state . state fold_config -> ta1 -> state -> (ta1' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.a_a1 x state continue_fold + +and fold_a_a2 : type state . state fold_config -> ta2 -> state -> (ta2' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.a_a2 x state continue_fold + +and fold_ta1 : type state . state fold_config -> ta1 -> state -> (ta1' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + let state = visitor.ta1_pre_state x state in + let (new_x, state) = visitor.ta1 x state continue_fold in + let state = visitor.ta1_post_state x new_x state in + (new_x, state) + +and fold_ta1_X : type state . state fold_config -> root -> state -> (root' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.ta1_X x state continue_fold + +and fold_ta1_Y : type state . state fold_config -> ta2 -> state -> (ta2' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.ta1_Y x state continue_fold + +and fold_ta2 : type state . state fold_config -> ta2 -> state -> (ta2' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + let state = visitor.ta2_pre_state x state in + let (new_x, state) = visitor.ta2 x state continue_fold in + let state = visitor.ta2_post_state x new_x state in + (new_x, state) + +and fold_ta2_Z : type state . state fold_config -> ta2 -> state -> (ta2' * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.ta2_Z x state continue_fold + +and fold_ta2_W : type state . state fold_config -> unit -> state -> (unit * state) = fun visitor x state -> + let continue_fold : state continue_fold = mk_continue_fold visitor in + visitor.ta2_W x state continue_fold + +let no_op : 'a fold_config = { + root = (fun v state continue -> + match v with + | A v -> let (v, state) = continue.root_A v state in (A' v, state) + | B v -> let (v, state) = continue.root_B v state in (B' v, state) + | C v -> let (v, state) = continue.root_C v state in (C' v, state) + ); + root_pre_state = (fun v state -> ignore v; state) ; + root_post_state = (fun v new_v state -> ignore (v, new_v); state) ; + root_A = (fun v state continue -> continue.a v state ) ; + root_B = (fun v state continue -> ignore continue; (v, state) ) ; + root_C = (fun v state continue -> ignore continue; (v, state) ) ; + a = (fun v state continue -> + match v with + { a1; a2; } -> + let (a1', state) = continue.a_a1 a1 state in + let (a2', state) = continue.a_a2 a2 state in + ({ a1'; a2'; }, state) + ); + a_pre_state = (fun v state -> ignore v; state) ; + a_post_state = (fun v new_v state -> ignore (v, new_v); state) ; + a_a1 = (fun v state continue -> continue.ta1 v state ) ; + a_a2 = (fun v state continue -> continue.ta2 v state ) ; + ta1 = (fun v state continue -> + match v with + | X v -> let (v, state) = continue.ta1_X v state in (X' v, state) + | Y v -> let (v, state) = continue.ta1_Y v state in (Y' v, state) + ); + ta1_pre_state = (fun v state -> ignore v; state) ; + ta1_post_state = (fun v new_v state -> ignore (v, new_v); state) ; + ta1_X = (fun v state continue -> continue.root v state ) ; + ta1_Y = (fun v state continue -> continue.ta2 v state ) ; + ta2 = (fun v state continue -> + match v with + | Z v -> let (v, state) = continue.ta2_Z v state in (Z' v, state) + | W v -> let (v, state) = continue.ta2_W v state in (W' v, state) + ); + ta2_pre_state = (fun v state -> ignore v; state) ; + ta2_post_state = (fun v new_v state -> ignore (v, new_v); state) ; + ta2_Z = (fun v state continue -> continue.ta2 v state ) ; + ta2_W = (fun v state continue -> ignore continue; (v, state) ) ; +} diff --git a/src/stages/adt_generator/generator.py b/src/stages/adt_generator/generator.py index 48b8c5fd4..65fe21878 100644 --- a/src/stages/adt_generator/generator.py +++ b/src/stages/adt_generator/generator.py @@ -1,49 +1,34 @@ moduleName = "A" -variant="_ _variant" -record="_ _record" -def poly(x): return x adts = [ - # typename, kind, fields_or_ctors - ("root", variant, [ - # ctor, builtin?, type - ("A", False, "rootA"), - ("B", False, "rootB"), + # typename, variant?, fields_or_ctors + ("root", True, [ + # ctor, builtin, type + ("A", False, "a"), + ("B", True, "int"), ("C", True, "string"), ]), - ("a", record, [ - # field, builtin?, type + ("a", False, [ ("a1", False, "ta1"), ("a2", False, "ta2"), ]), - ("ta1", variant, [ + ("ta1", True, [ ("X", False, "root"), ("Y", False, "ta2"), ]), - ("ta2", variant, [ + ("ta2", True, [ ("Z", False, "ta2"), ("W", True, "unit"), ]), - # polymorphic type - ("rootA", poly("list"), - [ - # Position (0..n-1), builtin?, type argument - (0, False, "a") - ]), - ("rootB", poly("list"), - [ - # Position (0..n-1), builtin?, type argument - (0, True, "int") - ]), ] from collections import namedtuple -adt = namedtuple('adt', ['name', 'newName', 'kind', 'ctorsOrFields']) +adt = namedtuple('adt', ['name', 'newName', 'isVariant', 'ctorsOrFields']) ctorOrField = namedtuple('ctorOrField', ['name', 'newName', 'isBuiltin', 'type_', 'newType']) adts = [ adt( name = name, newName = f"{name}'", - kind = kind, + isVariant = isVariant, ctorsOrFields = [ ctorOrField( name = cf, @@ -55,32 +40,23 @@ adts = [ for (cf, isBuiltin, type_) in ctors ], ) - for (name, kind, ctors) in adts + for (name, isVariant, ctors) in adts ] -print("(* This is an auto-generated file. Do not edit. *)") - -print("") print("open %s" % moduleName) print("") for (index, t) in enumerate(adts): typeOrAnd = "type" if index == 0 else "and" print(f"{typeOrAnd} {t.newName} =") - if t.kind == variant: + if t.isVariant: for c in t.ctorsOrFields: print(f" | {c.newName} of {c.newType}") - elif t.kind == record: + else: print(" {") for f in t.ctorsOrFields: print(f" {f.newName} : {f.newType} ;") print(" }") - else: - print(" ", end='') - for a in t.ctorsOrFields: - print(f"{a.newType}", end=' ') - print(t.kind, end='') - print("") print("") print(f"type 'state continue_fold =") @@ -131,10 +107,10 @@ print("let no_op : 'a fold_config = {") for t in adts: print(f" {t.name} = (fun v state continue ->") print(" match v with") - if t.kind == variant: + if t.isVariant: for c in t.ctorsOrFields: print(f" | {c.name} v -> let (v, state) = continue.{t.name}_{c.name} v state in ({c.newName} v, state)") - elif t.kind == record: + else: print(" {", end=' ') for f in t.ctorsOrFields: print(f"{f.name};", end=' ') @@ -145,10 +121,6 @@ for t in adts: for f in t.ctorsOrFields: print(f"{f.newName};", end=' ') print("}, state)") - else: - print(f" v -> fold_{t.kind} v state (", end=' ') - print(", ".join([f"continue.{t.name}_{f.name}" for f in t.ctorsOrFields]), end='') - print(" )") print(" );") print(f" {t.name}_pre_state = (fun v state -> ignore v; state) ;") print(f" {t.name}_post_state = (fun v new_v state -> ignore (v, new_v); state) ;") diff --git a/src/stages/adt_generator/use_a_fold.ml b/src/stages/adt_generator/use_a_fold.ml index 0fe476d42..6a73f4782 100644 --- a/src/stages/adt_generator/use_a_fold.ml +++ b/src/stages/adt_generator/use_a_fold.ml @@ -4,7 +4,7 @@ open Fold (* TODO: how should we plug these into our test framework? *) let () = - let some_root : root = A [{ a1 = X (A [{ a1 = X (B [1;2;3]) ; a2 = W () ; }]) ; a2 = Z (W ()) ; }] in + let some_root : root = A { a1 = X (A { a1 = X (B 1) ; a2 = W () ; }) ; a2 = Z (W ()) ; } in let op = { no_op with a = fun the_a state continue_fold -> @@ -23,7 +23,7 @@ let () = () let () = - let some_root : root = A [{ a1 = X (A [{ a1 = X (B [1;2;3]) ; a2 = W () ; }]) ; a2 = Z (W ()) ; }] in + let some_root : root = A { a1 = X (A { a1 = X (B 1) ; a2 = W () ; }) ; a2 = Z (W ()) ; } in let op = { no_op with a_pre_state = fun _the_a state -> state + 1 } in let state = 0 in let (_, state) = fold_root op some_root state in @@ -33,7 +33,7 @@ let () = () let () = - let some_root : root = A [{ a1 = X (A [{ a1 = X (B [1;2;3]) ; a2 = W () ; }]) ; a2 = Z (W ()) ; }] in + let some_root : root = A { a1 = X (A { a1 = X (B 1) ; a2 = W () ; }) ; a2 = Z (W ()) ; } in let op = { no_op with a_post_state = fun _the_a _new_a state -> state + 1 } in let state = 0 in let (_, state) = fold_root op some_root state in diff --git a/src/stages/ast_typed/types.ml b/src/stages/ast_typed/types.ml index 8804e49e7..5aa323c9b 100644 --- a/src/stages/ast_typed/types.ml +++ b/src/stages/ast_typed/types.ml @@ -95,6 +95,7 @@ and matching = and ascription = {anno_expr: expression; type_annotation: type_expression} + and environment_element_definition = | ED_binder | ED_declaration of (expression * free_variables) diff --git a/src/test/contracts/big_map.ligo b/src/test/contracts/big_map.ligo index 1a6dcfab0..9b8364ac3 100644 --- a/src/test/contracts/big_map.ligo +++ b/src/test/contracts/big_map.ligo @@ -16,6 +16,8 @@ function set_ (var n : int; var m : foo) : foo is block { m[23] := n } with m +function add (var n : int ; var m : foo) : foo is set_(n,m) + function rm (var m : foo) : foo is block { remove 42 from map m } with m diff --git a/src/test/contracts/big_map.mligo b/src/test/contracts/big_map.mligo index eb06bd5f4..35a173f82 100644 --- a/src/test/contracts/big_map.mligo +++ b/src/test/contracts/big_map.mligo @@ -1,8 +1,8 @@ type foo = (int, int) big_map -let set_2 (n : int) (m : foo) : foo = Big_map.update 23 (Some n) m +let set_ (n, m: int * foo) : foo = Big_map.update 23 (Some n) m -let set_ (t: int * foo) : foo = set_2 t.0 t.1 +let add (n,m : int * foo) : foo = Big_map.add 23 n m let rm (m : foo) : foo = Big_map.remove 42 m diff --git a/src/test/contracts/big_map.religo b/src/test/contracts/big_map.religo index 03b13b404..92f5431c8 100644 --- a/src/test/contracts/big_map.religo +++ b/src/test/contracts/big_map.religo @@ -4,6 +4,8 @@ let set2 = (n: int, m: foo): foo => Big_map.update(23, Some(n), m); let set_ = (x: (int, foo)): foo => set2(x[0], x[1]); +let add = ((n,m): (int, foo)): foo => Big_map.add(23, n, m); + let rm = (m: foo): foo => Big_map.remove(42, m); let gf = (m: foo): int => Big_map.find(23, m); diff --git a/src/test/integration_tests.ml b/src/test/integration_tests.ml index dac0564d2..f384db470 100644 --- a/src/test/integration_tests.ml +++ b/src/test/integration_tests.ml @@ -1079,6 +1079,11 @@ let big_map_ type_f path : unit result = let make_expected = fun n -> ez [(23 , n) ; (42 , 0)] in expect_eq_n_pos_small program "set_" make_input make_expected in + let%bind () = + let input = (e_pair (e_int 23) (ez [(42, 42)])) in + let expected = ez [(23, 23) ; (42, 42)] in + expect_eq program "add" input expected + in let%bind () = let make_input = fun n -> ez [(23, n) ; (42, 4)] in let make_expected = fun _ -> e_some @@ e_int 4 in diff --git a/src/test/md_file_tests.ml b/src/test/md_file_tests.ml index f697a18d4..247f396f1 100644 --- a/src/test/md_file_tests.ml +++ b/src/test/md_file_tests.ml @@ -122,6 +122,7 @@ let md_files = [ "/gitlab-pages/docs/advanced/timestamps-addresses.md"; "/gitlab-pages/docs/api/cli-commands.md"; "/gitlab-pages/docs/api/cheat-sheet.md"; + "/gitlab-pages/docs/reference/big_map.md"; "/gitlab-pages/docs/reference/string.md"; ] diff --git a/tools/webide/Dockerfile b/tools/webide/Dockerfile index 212b12130..4dfa9963a 100644 --- a/tools/webide/Dockerfile +++ b/tools/webide/Dockerfile @@ -17,7 +17,7 @@ FROM node:12-buster WORKDIR /app -RUN apt-get update && apt-get -y install python3 libev-dev perl pkg-config libgmp-dev libhidapi-dev m4 libcap-dev bubblewrap rsync +RUN apt-get update && apt-get -y install libev-dev perl pkg-config libgmp-dev libhidapi-dev m4 libcap-dev bubblewrap rsync COPY ligo_deb10.deb /tmp/ligo_deb10.deb RUN dpkg -i /tmp/ligo_deb10.deb && rm /tmp/ligo_deb10.deb diff --git a/vendors/UnionFind/UnionFind.install b/vendors/UnionFind/UnionFind.install new file mode 100644 index 000000000..692984e20 --- /dev/null +++ b/vendors/UnionFind/UnionFind.install @@ -0,0 +1,36 @@ +lib: [ + "_build/install/default/lib/UnionFind/META" + "_build/install/default/lib/UnionFind/Partition.cmi" + "_build/install/default/lib/UnionFind/Partition.cmti" + "_build/install/default/lib/UnionFind/Partition.mli" + "_build/install/default/lib/UnionFind/Partition0.cmi" + "_build/install/default/lib/UnionFind/Partition0.cmt" + "_build/install/default/lib/UnionFind/Partition0.cmx" + "_build/install/default/lib/UnionFind/Partition0.ml" + "_build/install/default/lib/UnionFind/Partition1.cmi" + "_build/install/default/lib/UnionFind/Partition1.cmt" + "_build/install/default/lib/UnionFind/Partition1.cmx" + "_build/install/default/lib/UnionFind/Partition1.ml" + "_build/install/default/lib/UnionFind/Partition2.cmi" + "_build/install/default/lib/UnionFind/Partition2.cmt" + "_build/install/default/lib/UnionFind/Partition2.cmx" + "_build/install/default/lib/UnionFind/Partition2.ml" + "_build/install/default/lib/UnionFind/Partition3.cmi" + "_build/install/default/lib/UnionFind/Partition3.cmt" + "_build/install/default/lib/UnionFind/Partition3.cmx" + "_build/install/default/lib/UnionFind/Partition3.ml" + "_build/install/default/lib/UnionFind/UnionFind.a" + "_build/install/default/lib/UnionFind/UnionFind.cma" + "_build/install/default/lib/UnionFind/UnionFind.cmxa" + "_build/install/default/lib/UnionFind/UnionFind.cmxs" + "_build/install/default/lib/UnionFind/dune-package" + "_build/install/default/lib/UnionFind/opam" + "_build/install/default/lib/UnionFind/unionFind.cmi" + "_build/install/default/lib/UnionFind/unionFind.cmt" + "_build/install/default/lib/UnionFind/unionFind.cmx" + "_build/install/default/lib/UnionFind/unionFind.ml" +] +doc: [ + "_build/install/default/doc/UnionFind/LICENSE" + "_build/install/default/doc/UnionFind/README.md" +]