balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'rinderknecht@contracts' into 'dev'

Browse Source 
Refactoring of the test contracts

See merge request ligolang/ligo!465
This commit is contained in:
Pierre-Emmanuel Wulfman 2020-03-04 19:26:50 +00:00
commit adc31a6e01
174 changed files with 1475 additions and 1717 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
src/bin/expect_tests/contract_tests.ml
View File

@ -7,7 +7,7 @@ let bad_contract basename =
let%expect_test _ =
run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ;
[%expect {| 1747 bytes |}] ;
[%expect {| 1870 bytes |}] ;
run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ;
[%expect {| 1324 bytes |}] ;
@ -16,7 +16,7 @@ let%expect_test _ =
[%expect {| 3231 bytes |}] ;
run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
[%expect {| 642 bytes |}] ;
[%expect {| 589 bytes |}] ;
run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
[%expect {| (Left (Left 1)) |}] ;
@ -86,7 +86,9 @@ let%expect_test _ =
SWAP ;
DIP { DUP ; CAR ; CAR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "buy_single: No card pattern." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
DIP { DUP ; CDR ; PUSH nat 1 ; ADD } ;
@ -159,7 +161,9 @@ let%expect_test _ =
SWAP ;
DIP { DUP ; CAR ; CDR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No card." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
SENDER ;
@ -173,7 +177,9 @@ let%expect_test _ =
CDR ;
DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No card pattern." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
DIP { DUP } ;
SWAP ;
@ -209,7 +215,9 @@ let%expect_test _ =
MUL ;
SENDER ;
CONTRACT unit ;
IF_NONE { PUSH string "bad address for get_contract" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No contract." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DIP { DUP } ;
SWAP ;
DIP { DUP } ;
@ -246,7 +254,9 @@ let%expect_test _ =
CAR ;
DIP { DUP } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "transfer_single: No card." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
SENDER ;
@ -938,40 +948,27 @@ let%expect_test _ =
run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
[%expect {|
{ parameter
(or (pair %init
(pair (timestamp %beginning_time) (timestamp %finish_time))
(string %title))
(string %vote)) ;
(or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title))
(or %vote (unit %nay) (unit %yea))) ;
storage
(pair (pair (pair (timestamp %beginning_time) (map %candidates string int))
(pair (timestamp %finish_time) (string %title)))
(set %voters address)) ;
(pair (pair (pair (timestamp %finish_time) (nat %nay))
(pair (timestamp %start_time) (string %title)))
(pair (set %voters address) (nat %yea))) ;
code { DUP ;
DUP ;
CAR ;
IF_LEFT
{ DUP ;
DIP { DIP { DUP } ; SWAP ; CDR } ;
PAIR ;
DUP ;
CAR ;
CAR ;
CAR ;
DIP { PUSH int 0 ;
SOME ;
DIP { PUSH int 0 ;
SOME ;
EMPTY_MAP string int ;
SWAP ;
PUSH string "Yes" ;
UPDATE } ;
PUSH string "No" ;
UPDATE } ;
PAIR ;
DIP { DUP ; CAR ; CAR ; CDR ; DIP { DUP ; CAR ; CDR } ; PAIR } ;
PAIR ;
EMPTY_SET address ;
PUSH nat 0 ;
SWAP ;
PAIR ;
DIP { DUP ; CAR ; CDR ; DIP { DUP ; CDR } ; PAIR } ;
PAIR ;
DIP { PUSH nat 0 ; EMPTY_SET address ; PAIR } ;
PAIR ;
NIL operation ;
PAIR ;
DIP { DROP 2 } }
@ -979,41 +976,56 @@ let%expect_test _ =
DIP { DIP { DUP } ; SWAP ; CDR } ;
PAIR ;
DUP ;
CDR ;
DIP { DUP } ;
SWAP ;
CAR ;
DIP { DUP ; CDR ; CAR ; CAR ; CDR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_LEFT
{ DIP { DUP } ;
SWAP ;
DIP 2 { DUP } ;
DIG 2 ;
CAR ;
CAR ;
CDR ;
PUSH nat 1 ;
ADD ;
DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
SWAP ;
PAIR ;
PAIR ;
PAIR ;
DIP { DROP } }
{ DIP { DUP } ;
SWAP ;
DIP 2 { DUP } ;
DIG 2 ;
CDR ;
CDR ;
PUSH nat 1 ;
ADD ;
DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ;
SWAP ;
PAIR ;
SWAP ;
PAIR ;
DIP { DROP } } ;
DUP ;
DIP { DUP } ;
SWAP ;
CDR ;
CAR ;
CAR ;
CAR ;
DIP { DIP { DUP } ;
SWAP ;
CAR ;
DIP { DUP ;
PUSH int 1 ;
ADD ;
SOME ;
DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CAR ; CDR } } ;
UPDATE } ;
PUSH bool True ;
SENDER ;
UPDATE ;
DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ;
PAIR ;
DIP { DIP { DUP } ;
SWAP ;
CDR ;
CAR ;
CDR ;
CAR ;
DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CDR ; CDR } ;
PAIR } ;
PAIR ;
DIP { DIP { DUP } ; SWAP ; CDR ; CDR ; PUSH bool True ; SENDER ; UPDATE } ;
SWAP ;
PAIR ;
NIL operation ;
PAIR ;
DIP { DROP 3 } } ;
DIP { DROP } } } |}]
DIP { DROP 4 } } ;
DIP { DROP 2 } } } |}]
let%expect_test _ =
run_ligo_good [ "compile-contract" ; contract "implicit.mligo" ; "main" ] ;
@ -1054,7 +1066,7 @@ let%expect_test _ =
let%expect_test _ =
run_ligo_bad [ "compile-contract" ; contract "bad_address_format.religo" ; "main" ] ;
[%expect {|
ligo: in file "bad_address_format.religo", line 2, characters 25-47. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 25-47"}
ligo: in file "bad_address_format.religo", line 2, characters 26-48. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 26-48"}
If you're not sure how to fix this error, you can
@ -1149,29 +1161,29 @@ let%expect_test _ =
let%expect_test _ =
run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_toplevel.mligo" ; "main" ] ;
[%expect {|
ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#756 = #P in let p = rhs#756.0 in let s = rhs#756.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#808 = #P in let p = rhs#808.0 in let s = rhs#808.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
If you're not sure how to fix this error, you can
do one of the following:
If you're not sure how to fix this error, you can
do one of the following:
* Visit our documentation: https://ligolang.org/docs/intro/what-and-why/
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;
* Visit our documentation: https://ligolang.org/docs/intro/what-and-why/
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;
run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_var.mligo" ; "main" ] ;
[%expect {|
ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#759 = #P in let p = rhs#759.0 in let s = rhs#759.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#811 = #P in let p = rhs#811.0 in let s = rhs#811.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
If you're not sure how to fix this error, you can
do one of the following:
If you're not sure how to fix this error, you can
do one of the following:
* Visit our documentation: https://ligolang.org/docs/intro/what-and-why/
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;
* Visit our documentation: https://ligolang.org/docs/intro/what-and-why/
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;
run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_no_inline.mligo" ; "main" ] ;
[%expect {|

53
src/passes/operators/operators.ml
View File

@ -68,31 +68,30 @@ module Simplify = struct
(* Tezos module (ex-Michelson) *)
| "Tezos.chain_id" -> ok C_CHAIN_ID
| "chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "get_chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "get_chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "Tezos.balance" -> ok C_BALANCE
| "balance" -> ok C_BALANCE (* Deprecated *)
| "balance" -> ok C_BALANCE (* Deprecated *)
| "Tezos.now" -> ok C_NOW
| "now" -> ok C_NOW (* Deprecated *)
| "now" -> ok C_NOW (* Deprecated *)
| "Tezos.amount" -> ok C_AMOUNT
| "amount" -> ok C_AMOUNT (* Deprecated *)
| "amount" -> ok C_AMOUNT (* Deprecated *)
| "Tezos.sender" -> ok C_SENDER
| "sender" -> ok C_SENDER (* Deprecated *)
| "sender" -> ok C_SENDER (* Deprecated *)
| "Tezos.address" -> ok C_ADDRESS
| "address" -> ok C_ADDRESS (* Deprecated *)
| "address" -> ok C_ADDRESS (* Deprecated *)
| "Tezos.self_address" -> ok C_SELF_ADDRESS
| "self_address" -> ok C_SELF_ADDRESS (* Deprecated *)
| "self_address" -> ok C_SELF_ADDRESS (* Deprecated *)
| "Tezos.implicit_account" -> ok C_IMPLICIT_ACCOUNT
| "implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "Tezos.source" -> ok C_SOURCE
| "source" -> ok C_SOURCE (* Deprecated *)
| "source" -> ok C_SOURCE (* Deprecated *)
| "Tezos.failwith" -> ok C_FAILWITH
| "failwith" -> ok C_FAILWITH
| "failwith" -> ok C_FAILWITH
| "Tezos.create_contract" -> ok C_CREATE_CONTRACT
| "Tezos.transaction" -> ok C_CALL
| "Tezos.transaction" -> ok C_CALL
| "transaction" -> ok C_CALL (* Deprecated *)
| "Tezos.set_delegate" -> ok C_SET_DELEGATE
| "Tezos.set_delegate" -> ok C_SET_DELEGATE
| "set_delegate" -> ok C_SET_DELEGATE (* Deprecated *)
| "get_contract" -> ok C_CONTRACT (* Deprecated *)
| "Tezos.get_contract_opt" -> ok C_CONTRACT_OPT
@ -145,7 +144,7 @@ module Simplify = struct
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "bytes_unpack" -> ok C_BYTES_UNPACK (* Deprecated *)
| "Bytes.length" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "bytes_concat" -> ok C_CONCAT (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE
@ -166,7 +165,8 @@ module Simplify = struct
(* Set module *)
| "Set.size" -> ok C_SIZE
| "Set.cardinal" -> ok C_SIZE
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "set_size" -> ok C_SIZE (* Deprecated *)
| "set_empty" -> ok C_SET_EMPTY (* Deprecated *)
| "Set.mem" -> ok C_SET_MEM
@ -326,9 +326,9 @@ module Simplify = struct
| "Bytes.pack" -> ok C_BYTES_PACK
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "Bytes.length" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE
| "Bytes.slice" -> ok C_SLICE (* Deprecated *)
| "Bytes.sub" -> ok C_SLICE
(* List module *)
@ -341,14 +341,15 @@ module Simplify = struct
(* Set module *)
| "Set.mem" -> ok C_SET_MEM
| "Set.iter" -> ok C_SET_ITER
| "Set.empty" -> ok C_SET_EMPTY
| "Set.literal" -> ok C_SET_LITERAL
| "Set.add" -> ok C_SET_ADD
| "Set.remove" -> ok C_SET_REMOVE
| "Set.fold" -> ok C_SET_FOLD
| "Set.size" -> ok C_SIZE
| "Set.mem" -> ok C_SET_MEM
| "Set.iter" -> ok C_SET_ITER
| "Set.empty" -> ok C_SET_EMPTY
| "Set.literal" -> ok C_SET_LITERAL
| "Set.add" -> ok C_SET_ADD
| "Set.remove" -> ok C_SET_REMOVE
| "Set.fold" -> ok C_SET_FOLD
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "Set.cardinal" -> ok C_SIZE
(* Map module *)

6
src/test/contracts/address.ligo
View File

@ -1,5 +1,3 @@
// function main (const c : contract (unit)) : address is address (c)
function main (const p : key_hash) : address is block {
const c : contract (unit) = implicit_account (p);
} with address (c)
const c : contract (unit) = Tezos.implicit_account (p);
} with Tezos.address (c)

4
src/test/contracts/address.mligo
View File

@ -1,3 +1,3 @@
let main (p : key_hash) =
let c : unit contract = Current.implicit_account p in
Current.address c
let c : unit contract = Tezos.implicit_account p
in Tezos.address c

4
src/test/contracts/address.religo
View File

@ -1,4 +1,4 @@
let main = (p : key_hash) : address => {
let c : contract(unit) = Current.implicit_account(p) ;
Current.address(c) ;
let c : contract (unit) = Tezos.implicit_account (p);
Tezos.address(c);
};

11
src/test/contracts/amount.ligo
View File

@ -1,8 +1,5 @@
function check (const p: unit) : int is
begin
function check (const p : unit) : int is
block {
var result : int := 0;
if amount = 100tz then
result := 42
else
result := 0
end with result
if amount = 100tez then result := 42 else result := 0
} with result

2
src/test/contracts/amount.mligo
View File

@ -1 +1 @@
let check_ (p: unit) : int = if Current.amount = 100tz then 42 else 0
let check_ (p : unit) : int = if Tezos.amount = 100tez then 42 else 0

9
src/test/contracts/amount.religo
View File

@ -1,7 +1,2 @@
let check_ = (p: unit) : int =>
if (Current.amount == 100tz) {
42;
}
else {
0;
};
let check_ = (p : unit) : int =>
if (Tezos.amount == 100tez) { 42; } else { 0; };

18
src/test/contracts/arithmetic.ligo
View File

@ -1,15 +1,7 @@
// Test PascaLIGO arithmetic operators
function mod_op (const n : int) : nat is n mod 42
function plus_op (const n : int) : int is n + 42
function mod_op (const n : int) : nat is n mod 42
function plus_op (const n : int) : int is n + 42
function minus_op (const n : int) : int is n - 42
function times_op (const n : int) : int is n * 42
function div_op (const n : int) : int is n / 2
function int_op (const n : nat) : int is int (n)
function neg_op (const n : int) : int is -n
function div_op (const n : int) : int is n / 2
function int_op (const n : nat) : int is int (n)
function neg_op (const n : int) : int is -n

38
src/test/contracts/arithmetic.mligo
View File

@ -1,30 +1,8 @@
// Test CameLIGO arithmetic operators
let mod_op (n : int) : nat =
n mod 42
let plus_op (n : int) : int =
n + 42
let minus_op (n : int) : int =
n - 42
let times_op (n : int) : int =
n * 42
let div_op (n : int) : int =
n / 2
(* TODO (?): Support conversion from nat to int and back
let int_op (n : nat) : int =
Int n
*)
let neg_op (n : int) : int =
-n
let foo (n : int) : int = n + 10
let neg_op_2 (b: int) : int = -(foo b)
let mod_op (n : int) : nat = n mod 42
let plus_op (n : int) : int = n + 42
let minus_op (n : int) : int = n - 42
let times_op (n : int) : int = n * 42
let div_op (n : int) : int = n / 2
let neg_op (n : int) : int = -n
let foo (n : int) : int = n + 10
let neg_op_2 (b : int) : int = -(foo b)

30
src/test/contracts/arithmetic.religo
View File

@ -1,24 +1,10 @@
/* Test ReasonLIGO arithmetic operators */
let mod_op = (n: int): nat => n mod 42;
let plus_op = (n: int): int => n + 42;
let minus_op = (n: int): int => n - 42;
let times_op = (n: int): int => n * 42;
let div_op = (n: int): int => n / 2;
/* TODO (?): Support conversion from nat to int and back
let int_op (n : nat) : int =
Int n
*/
let neg_op = (n: int): int => - n;
let foo = (n: int): int => n + 10;
let neg_op_2 = (b: int): int => - foo(b);
let mod_op = (n : int) : nat => n mod 42;
let plus_op = (n : int) : int => n + 42;
let minus_op = (n : int) : int => n - 42;
let times_op = (n : int) : int => n * 42;
let div_op = (n : int) : int => n / 2;
let neg_op = (n : int): int => - n;
let foo = (n : int): int => n + 10;
let neg_op_2 = (b : int): int => -foo(b);

2
src/test/contracts/assert.mligo
View File

@ -1,3 +1,3 @@
let main (p, s: bool * unit) =
let main (p, s : bool * unit) =
let u : unit = assert p
in ([] : operation list), s

6
src/test/contracts/assert.religo
View File

@ -1,4 +1,4 @@
let main = (p: bool, s: unit) => {
let u: unit = assert(p);
([]: list(operation), s);
let main = (p, s : bool, unit) => {
let u : unit = assert (p);
([]: list (operation), s);
};

5
src/test/contracts/assign.ligo
View File

@ -1,4 +1 @@
function main (const i : int) : int is
block {
i := i + 1
} with i
function main (const i : int) : int is block {i := i + 1} with i

9
src/test/contracts/attributes.mligo
View File

@ -1,10 +1,7 @@
let x = 1 [@@inline]
let foo (a: int): int =
let foo (a : int): int =
(let test = 2 + a [@@inline] in test) [@@inline]
let y = 1 [@@inline][@@other]
let bar (b: int): int =
let test = fun (z: int) -> 2 + b + z [@@inline][@@foo][@@bar]
let bar (b : int): int =
let test = fun (z : int) -> 2 + b + z [@@inline][@@foo][@@bar]
in test b

8
src/test/contracts/attributes.religo
View File

@ -2,7 +2,7 @@
let x = 1;
[@inline]
let foo = (a: int): int => {
let foo = (a : int) : int => {
[@inline]
let test = 2 + a;
test;
@ -11,8 +11,8 @@ let foo = (a: int): int => {
[@inline][@other]
let y = 1;
let bar = (b: int): int => {
let bar = (b : int) : int => {
[@inline][@foo][@bar]
let test = (z: int) => 2 + b + z;
test(b);
let test = (z : int) => 2 + b + z;
test (b);
};

5
src/test/contracts/bad_address_format.religo
View File

@ -1,3 +1,2 @@
let main = (parameter: int, storage: address) => {
([]:list(operation), "KT1badaddr" : address);
};
let main = (parameter : int, storage : address) =>
([] : list (operation), "KT1badaddr" : address);

2
src/test/contracts/bad_timestamp.ligo
View File

@ -6,4 +6,4 @@ function main (const p : parameter; const s : storage) : return is
block {
var stamp : timestamp := ("badtimestamp" : timestamp)
}
with ((nil: list(operation)), stamp)
with ((nil : list (operation)), stamp)

2
src/test/contracts/balance_constant.ligo
View File

@ -9,4 +9,4 @@ type storage is tez
type return is list (operation) * storage
function main (const param : parameter; const store: storage) : return is
((nil : list (operation)), balance)
((nil : list (operation)), Tezos.balance)

17
src/test/contracts/balance_constant.mligo
View File

@ -1,17 +1,18 @@
(**
(*
This test makes sure that the balance is accessible in CameLIGO.
It's there to detect a regression of: https://gitlab.com/ligolang/ligo/issues/61
Which results in this error when you attempt to compile this contract:
It is there to detect a regression of:
https://gitlab.com/ligolang/ligo/issues/61
which results in this error when you attempt to compile this contract:
generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
*)
type parameter = unit
type storage = tez
type return = operation list * storage
let main (p, s : unit * storage) =
([] : operation list), balance
let main (p, s : parameter * storage) : return =
([] : operation list), Tezos.balance

5
src/test/contracts/balance_constant.religo
View File

@ -12,6 +12,7 @@ generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
type storage = tez;
let main2 = (p: unit, s: storage) => ([]: list(operation), balance);
let main2 = (p : unit, storage) =>
([]: list (operation), Tezos.balance);
let main = (x: (unit, storage)) => main2(x[0],x[1]);
let main = (x : (unit, storage)) => main2 (x[0], x[1]);

6
src/test/contracts/big_map.ligo
View File

@ -8,7 +8,7 @@ function main (const p : parameter; const s : storage) : return is
toto := s.0[23];
s.0[2] := 444
}
with ((nil: list(operation)), s)
with ((nil : list (operation)), s)
type foo is big_map (int, int)
@ -16,14 +16,12 @@ 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 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
function gf (const m : foo) : int is get_force (23, m)
function get (const m : foo) : option (int) is m[42]
const empty_big_map : big_map (int,int) = big_map []

17
src/test/contracts/big_map.mligo
View File

@ -1,23 +1,18 @@
type foo = (int, int) big_map
let set_ (n, m: int * foo) : foo = Big_map.update 23 (Some n) m
let add (n,m : int * foo) : foo = Big_map.add 23 n m
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
let get (m: foo): int option = Big_map.find_opt 42 m
let get (m : foo): int option = Big_map.find_opt 42 m
let empty_map : foo = Big_map.empty
let map1 : foo = Big_map.literal
[ (23 , 0) ; (42, 0) ]
let map1 : foo = Big_map.literal
[ (23 , 0) ; (42, 0) ]
let map1 : foo = Big_map.literal [(23,0); (42,0)]
let map1 : foo = Big_map.literal [(23,0); (42,0)]
let mutimaps (m : foo) (n : foo) : foo =
let bar : foo = Big_map.update 42 (Some 0) m in
Big_map.update 42 (get bar) n
let bar : foo = Big_map.update 42 (Some 0) m
in Big_map.update 42 (get bar) n

22
src/test/contracts/big_map.religo
View File

@ -1,24 +1,22 @@
type foo = big_map(int, int);
let set2 = (n: int, m: foo): foo => Big_map.update(23, Some(n), m);
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 set_ = (x : (int, foo)) : foo => set2 (x[0], x[1]);
let add = ((n,m): (int, foo)): foo => Big_map.add(23, n, m);
let add = ((n,m) : (int, foo)) : foo => Big_map.add (23, n, m);
let rm = (m: foo): foo => Big_map.remove(42, m);
let rm = (m : foo) : foo => Big_map.remove (42, m);
let gf = (m: foo): int => Big_map.find(23, m);
let gf = (m : foo) : int => Big_map.find (23, m);
let get = (m: foo): option(int) => Big_map.find_opt(42, m);
let get = (m : foo) : option (int) => Big_map.find_opt (42, m);
let empty_map: foo = Big_map.empty;
let empty_map : foo = Big_map.empty;
let map1: foo = Big_map.literal([(23, 0), (42, 0)]);
let map1: foo = Big_map.literal([(23, 0), (42, 0)]);
let map1 : foo = Big_map.literal ([(23,0), (42,0)]);
let mutimaps = (m: foo, n: foo): foo => {
let bar: foo = Big_map.update(42, Some(0), m);
Big_map.update(42, get(bar), n);
let bar : foo = Big_map.update (42, Some (0), m);
Big_map.update (42, get (bar), n);
};

10
src/test/contracts/bitwise_arithmetic.mligo
View File

@ -1,7 +1,7 @@
(* Test CameLIGO bitwise operators *)
let or_op (n: nat) : nat = Bitwise.or n 4n
let and_op (n: nat) : nat = Bitwise.and n 7n
let xor_op (n: nat) : nat = Bitwise.xor n 7n
let lsl_op (n: nat) : nat = Bitwise.shift_left n 7n
let lsr_op (n: nat) : nat = Bitwise.shift_right n 7n
let or_op (n : nat) : nat = Bitwise.or n 4n
let and_op (n : nat) : nat = Bitwise.and n 7n
let xor_op (n : nat) : nat = Bitwise.xor n 7n
let lsl_op (n : nat) : nat = Bitwise.shift_left n 7n
let lsr_op (n : nat) : nat = Bitwise.shift_right n 7n

14
src/test/contracts/boolean_operators.ligo
View File

@ -1,11 +1,5 @@
// Test PascaLIGO boolean operators
function or_true (const b : bool) : bool is b or True
function or_false (const b : bool) : bool is b or False
function and_true (const b : bool) : bool is b and True
function or_true (const b : bool) : bool is b or True
function or_false (const b : bool) : bool is b or False
function and_true (const b : bool) : bool is b and True
function and_false (const b : bool) : bool is b and False
function not_bool (const b : bool) : bool is not b
function not_bool (const b : bool) : bool is not b

19
src/test/contracts/boolean_operators.mligo
View File

@ -1,16 +1,7 @@
// Test CameLIGO boolean operators
let or_true (b : bool) : bool =
b || true
let or_false (b : bool) : bool =
b || false
let and_true (b : bool) : bool =
b && true
let and_false (b : bool) : bool =
b && false
let not_bool (b: bool) : bool =
not b
let or_true (b : bool) : bool = b || true
let or_false (b : bool) : bool = b || false
let and_true (b : bool) : bool = b && true
let and_false (b : bool) : bool = b && false
let not_bool (b : bool) : bool = not b

14
src/test/contracts/boolean_operators.religo
View File

@ -1,11 +1,7 @@
// Test ReasonLIGO boolean operators
let or_true = (b: bool): bool => b || true;
let or_false = (b: bool): bool => b || false;
let and_true = (b: bool): bool => b && true;
let and_false = (b: bool): bool => b && false;
let not_bool = (b: bool): bool => !b;
let or_true = (b : bool) : bool => b || true;
let or_false = (b : bool) : bool => b || false;
let and_true = (b : bool) : bool => b && true;
let and_false = (b : bool) : bool => b && false;
let not_bool = (b : bool) : bool => !b;

8
src/test/contracts/bytes_arithmetic.ligo
View File

@ -1,5 +1,3 @@
function concat_op (const s : bytes) : bytes is bytes_concat (s, 0x7070)
function slice_op (const s : bytes) : bytes is bytes_slice (1n, 2n, s)
function hasherman (const s : bytes) : bytes is sha_256 (s)
function concat_op (const s : bytes) : bytes is Bytes.concat (s, 0x7070)
function slice_op (const s : bytes) : bytes is Bytes.sub (1n, 2n, s)
function hasherman (const s : bytes) : bytes is Crypto.sha256 (s)

11
src/test/contracts/bytes_arithmetic.mligo
View File

@ -1,8 +1,3 @@
let concat_op (s : bytes) : bytes =
Bytes.concat s 0x7070
let slice_op (s : bytes) : bytes =
Bytes.slice 1n 2n s
let hasherman (s : bytes) : bytes =
Crypto.sha256 s
let concat_op (s : bytes) : bytes = Bytes.concat s 0x7070
let slice_op (s : bytes) : bytes = Bytes.sub 1n 2n s
let hasherman (s : bytes) : bytes = Crypto.sha256 s

12
src/test/contracts/bytes_unpack.ligo
View File

@ -1,11 +1,11 @@
function id_string (const p : string) : option (string) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (string))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (string))
function id_int (const p : int) : option (int) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (int))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (int))
function id_address (const p : address) : option (address) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (address))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (address))

18
src/test/contracts/bytes_unpack.mligo
View File

@ -1,11 +1,11 @@
let id_string (p: string) : string option =
let packed: bytes = Bytes.pack p in
((Bytes.unpack packed): string option)
let id_string (p : string) : string option =
let packed : bytes = Bytes.pack p in
(Bytes.unpack packed : string option)
let id_int (p: int) : int option =
let packed: bytes = Bytes.pack p in
((Bytes.unpack packed): int option)
let id_int (p : int) : int option =
let packed : bytes = Bytes.pack p in
(Bytes.unpack packed : int option)
let id_address (p: address) : address option =
let packed: bytes = Bytes.pack p in
((Bytes.unpack packed): address option)
let id_address (p : address) : address option =
let packed : bytes = Bytes.pack p in
(Bytes.unpack packed : address option)

18
src/test/contracts/bytes_unpack.religo
View File

@ -1,14 +1,14 @@
let id_string = (p: string) : option(string) => {
let packed : bytes = Bytes.pack(p);
((Bytes.unpack(packed)): option(string));
let id_string = (p : string) : option(string) => {
let packed : bytes = Bytes.pack (p);
((Bytes.unpack (packed)) : option (string));
};
let id_int = (p: int) : option(int) => {
let packed: bytes = Bytes.pack(p);
((Bytes.unpack(packed)): option(int));
let id_int = (p : int) : option (int) => {
let packed : bytes = Bytes.pack (p);
((Bytes.unpack (packed)) : option (int));
};
let id_address = (p: address) : option(address) => {
let packed: bytes = Bytes.pack(p);
((Bytes.unpack(packed)): option(address));
let id_address = (p : address) : option (address) => {
let packed : bytes = Bytes.pack (p);
((Bytes.unpack (packed)) : option (address));
};

2
src/test/contracts/chain_id.ligo
View File

@ -1 +1 @@
function chain_id (const tt : chain_id) : chain_id is get_chain_id
function chain_id (const tt : chain_id) : chain_id is Tezos.chain_id

6
src/test/contracts/check_signature.ligo
View File

@ -1,4 +1,4 @@
function check_signature (const pk : key;
function check_signature (const pk : key;
const signed : signature;
const msg: bytes) : bool
is crypto_check (pk, signed, msg)
const msg : bytes) : bool
is Crypto.check (pk, signed, msg)

2
src/test/contracts/check_signature.mligo
View File

@ -1,2 +1,2 @@
let check_signature (pk, signed, msg: key * signature * bytes) : bool =
let check_signature (pk, signed, msg : key * signature * bytes) : bool =
Crypto.check pk signed msg

4
src/test/contracts/check_signature.religo
View File

@ -1,4 +1,4 @@
let check_signature = (param: (key, signature, bytes)) : bool => {
let check_signature = (param : (key, signature, bytes)) : bool => {
let pk, signed, msg = param;
Crypto.check(pk, signed, msg);
Crypto.check (pk, signed, msg);
};

14
src/test/contracts/closure.mligo
View File

@ -1,9 +1,7 @@
(* Test whether closures retain values in CameLIGO *)
(* Test whether closures capture variables in CameLIGO *)
let test (k: int) : int =
let j: int = k + 5 in
let close: (int -> int) =
fun (i: int) -> i + j
in
let j: int = 20 in (* Shadow original variable to see if value close'd *)
close 20
let test (k : int) : int =
let j : int = k + 5 in
let close : int -> int = fun (i : int) -> i + j in
let j : int = 20 (* Shadow original variable *)
in close 20

10
src/test/contracts/closure.religo
View File

@ -1,9 +1,9 @@
/* Test whether closures retain values in ReasonLIGO */
let test = (k: int): int => {
let j: int = k + 5;
let close: (int => int) = (i: int) => i + j;
let test = (k : int) : int => {
let j : int = k + 5;
let close : (int => int) = (i : int) => i + j;
let j: int = 20; /* Shadow original variable to see if value close'd */
close(20);
let j : int = 20; /* Shadow original variable */
close (20);
};

42
src/test/contracts/coase.ligo
View File

@ -45,27 +45,38 @@ type parameter is
| Transfer_single of action_transfer_single
function transfer_single (const action : action_transfer_single;
const s : storage) : return is block {
const s : storage) : return is
block {
const cards : cards = s.cards;
const card : card = get_force (action.card_to_transfer, cards);
const card : card =
case cards[action.card_to_transfer] of
Some (card) -> card
| None -> (failwith ("transfer_single: No card.") : card)
end;
if card.card_owner =/= sender then
failwith ("This card doesn't belong to you")
else skip;
card.card_owner := action.destination;
cards[action.card_to_transfer] := card;
s.cards := cards;
const operations : list (operation) = nil
} with (operations, s)
s.cards := cards
} with ((nil : list (operation)), s)
function sell_single (const action : action_sell_single;
const s : storage) : return is
block {
const card : card = get_force (action.card_to_sell, s.cards);
const card : card =
case s.cards[action.card_to_sell] of
Some (card) -> card
| None -> (failwith ("sell_single: No card.") : card)
end;
if card.card_owner =/= sender
then failwith ("This card doesn't belong to you")
else skip;
const card_pattern : card_pattern =
get_force (card.card_pattern, s.card_patterns);
case s.card_patterns[card.card_pattern] of
Some (pattern) -> pattern
| None -> (failwith ("sell_single: No card pattern.") : card_pattern)
end;
card_pattern.quantity := abs (card_pattern.quantity - 1n);
const card_patterns : card_patterns = s.card_patterns;
card_patterns[card.card_pattern] := card_pattern;
@ -74,8 +85,12 @@ function sell_single (const action : action_sell_single;
remove action.card_to_sell from map cards;
s.cards := cards;
const price : tez = card_pattern.coefficient * card_pattern.quantity;
const receiver : contract (unit) = get_contract (sender);
const op : operation = transaction (unit, price, receiver);
const receiver : contract (unit) =
case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
Some (contract) -> contract
| None -> (failwith ("sell_single: No contract.") : contract (unit))
end;
const op : operation = Tezos.transaction (unit, price, receiver);
const operations : list (operation) = list [op]
} with (operations, s)
@ -84,12 +99,13 @@ function buy_single (const action : action_buy_single;
block {
// Check funds
const card_pattern : card_pattern =
get_force (action.card_to_buy, s.card_patterns);
case s.card_patterns[action.card_to_buy] of
Some (pattern) -> pattern
| None -> (failwith ("buy_single: No card pattern.") : card_pattern)
end;
const price : tez =
card_pattern.coefficient * (card_pattern.quantity + 1n);
if price > amount then failwith ("Not enough money") else skip;
// Administrative procedure
const operations : list(operation) = nil;
// Increase quantity
card_pattern.quantity := card_pattern.quantity + 1n;
const card_patterns : card_patterns = s.card_patterns;
@ -103,7 +119,7 @@ function buy_single (const action : action_buy_single;
];
s.cards := cards;
s.next_id := s.next_id + 1n
} with (operations, s)
} with ((nil : list (operation)), s)
function main (const action : parameter; const s : storage) : return is
case action of

6
src/test/contracts/condition-annot.mligo
View File

@ -1,2 +1,4 @@
let main (i: int) =
if (i=2 : bool) then (42: int) else (0: int)
type integer = int
let main (i : int) =
if (i = 2 : bool) then (42 : int) else (0 : integer)

8
src/test/contracts/condition-annot.religo
View File

@ -1,6 +1,2 @@
let main = (i: int) =>
if (((i == 2): bool)) {
(42: int);
} else {
(0: int);
};
let main = (i : int) =>
if (((i == 2) : bool)) { (42 : int); } else { (0 : int); };

11
src/test/contracts/condition-shadowing.mligo
View File

@ -1,8 +1,5 @@
(* TODO : make a test using mutation, not shadowing *)
let main (i: int) =
let main (i : int) =
let result = 0 in
if i = 2 then
let result = 42 in result
else
let result = 0 in result
if i = 2
then let result = 42 in result
else let result = 0 in result

2
src/test/contracts/condition.mligo
View File

@ -1,3 +1,3 @@
// Test conditional in CameLIGO
let main (i: int) = if i = 2 then 42 else 0
let main (i : int) = if i = 2 then 42 else 0

7
src/test/contracts/condition.religo
View File

@ -1,8 +1,3 @@
/* Test conditional in ReasonLIGO */
let main = (i: int) =>
if (i == 2) {
42;
} else {
0;
};
let main = (i : int) => if (i == 2) { 42; } else { 0; };

4
src/test/contracts/counter.ligo
View File

@ -1,7 +1,7 @@
type t is int
function main (const p : int ; const s : t) : list (operation) * int is
function main (const p : int; const s : t) : list (operation) * int is
block {
skip
} // skip is a do nothing instruction, needed for empty blocks
with ((nil : list(operation)), p + s)
with ((nil : list (operation)), p+s)

3
src/test/contracts/counter.mligo
View File

@ -1,4 +1,3 @@
type storage = int
let main (ps: int * storage) =
(([] : operation list) , ps.0 + ps.1)
let main (p, s : int * storage) = ([] : operation list), p + s

6
src/test/contracts/counter.religo
View File

@ -1,6 +1,4 @@
type storage = int;
let main2 = (p: int, s: storage): string => ([]: list(operation), p + s);
let main = (x: (int, storage)) : string => main2(x[0],x[1]);
let main = ((p, s) : (int, storage)) : (list (operation), storage) =>
([] : list (operation), p + s);

5
src/test/contracts/crypto.ligo
View File

@ -1,3 +1,2 @@
function hasherman512 (const s: bytes) : bytes is sha_512 (s)
function hasherman_blake (const s: bytes) : bytes is blake2b (s)
function hasherman512 (const s : bytes) : bytes is Crypto.sha512 (s)
function hasherman_blake (const s : bytes) : bytes is Crypto.blake2b (s)

4
src/test/contracts/crypto.mligo
View File

@ -1,2 +1,2 @@
let hasherman512 (s: bytes) : bytes = Crypto.sha512 s
let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s
let hasherman512 (s : bytes) : bytes = Crypto.sha512 s
let hasherman_blake (s : bytes) : bytes = Crypto.blake2b s

4
src/test/contracts/crypto.religo
View File

@ -1,2 +1,2 @@
let hasherman512 = (s: bytes) => Crypto.sha512(s);
let hasherman_blake = (s: bytes) => Crypto.blake2b(s);
let hasherman512 = (s : bytes) => Crypto.sha512 (s);
let hasherman_blake = (s : bytes) => Crypto.blake2b (s);

14
src/test/contracts/curry.mligo
View File

@ -1,9 +1,5 @@
let conv_test (j: int) (k: int) = j + k
let main (i: int) : int = conv_test i 10
let partial (a: int) (b: int) : int = a + b
let mk_partial (j: int) : (int -> int) = partial j
let partial_apply (i: int) : int = (mk_partial 10) i
let conv_test (j : int) (k : int) = j + k
let main (i : int) : int = conv_test i 10
let partial (a : int) (b : int) : int = a + b
let mk_partial (j : int) : int -> int = partial j
let partial_apply (i : int) : int = mk_partial 10 i

2
src/test/contracts/declarations.ligo
View File

@ -1,5 +1,3 @@
// Test PascaLIGO top-level declarations
const foo : int = 42
function main (const i : int) : int is i + foo

7
src/test/contracts/deep_access.ligo
View File

@ -21,9 +21,12 @@ function asymetric_tuple_access (const foo : unit) : int is
} with tuple.0 + tuple.1.0 + tuple.1.1.0 + tuple.1.1.1
type nested_record_t is
record [nesty : record [mymap : map (int,string)]]
record [nesty : record [mymap : map (int, string)]]
function nested_record (var nee : nested_record_t) : string is
block {
nee.nesty.mymap[1] := "one"
} with get_force (1, nee.nesty.mymap)
} with case nee.nesty.mymap[1] of
Some (s) -> s
| None -> (failwith ("Should not happen.") : string)
end

1
src/test/contracts/dispatch-counter.ligo
View File

@ -7,7 +7,6 @@ type storage is int
type return is list (operation) * storage
function increment (const i : int; const n : int) : int is i+n
function decrement (const i : int; const n : int) : int is i-n
const nop : list (operation) = nil

12
src/test/contracts/empty_case.mligo
View File

@ -1,8 +1,8 @@
type foo =
| Bar of int
| Baz
Bar of int
| Baz
let main (f: foo): int =
match f with
| Bar i -> i
| Baz -> -1
let main (f : foo) : int =
match f with
Bar i -> i
| Baz -> -1

10
src/test/contracts/empty_case.religo
View File

@ -1,9 +1,9 @@
type foo =
| Bar(int)
| Baz;
| Bar (int)
| Baz;
let main = (f: foo): int =>
let main = (f : foo) : int =>
switch (f) {
| Bar(i) => i
| Baz => (-1)
| Bar (i) => i
| Baz => (-1)
};

7
src/test/contracts/entrypoints.ligo
View File

@ -5,8 +5,7 @@ type return is list (operation) * storage
function cb (const a : address; const s : storage) : return is
block {
const c : contract (unit) = get_entrypoint ("%cb", a)
}
with (list [transaction (unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)
function cbo (const a : address; const s : storage) : return is
@ -14,6 +13,6 @@ function cbo (const a : address; const s : storage) : return is
const c : contract (unit) =
case (get_entrypoint_opt ("%cbo", a) : option (contract (unit))) of
Some (c) -> c
| None -> (failwith ("entrypoint not found") : contract (unit))
| None -> (failwith ("cbo: Entrypoint not found.") : contract (unit))
end
} with (list [transaction(unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)

2
src/test/contracts/eq_bool.mligo
View File

@ -1,3 +1,3 @@
// Test conditional in CameLIGO
let main (a , b : bool * bool) = if a = b then 999 else 1
let main (a, b : bool * bool) = if a = b then 999 else 1

8
src/test/contracts/eq_bool.religo
View File

@ -1,8 +1,4 @@
/* Test boolean comparison in ReasonLIGO */
let main = ((a , b) : (bool , bool)) =>
if (a == b) {
999;
} else {
1;
};
let main = ((a, b) : (bool, bool)) =>
if (a == b) { 999; } else { 1; };

4
src/test/contracts/failwith.mligo
View File

@ -1,4 +1,4 @@
type storage = unit
let main (p: unit) (s:storage) =
if true then failwith "This contract always fails" else ()
let main (p, store : unit * storage) : operation list * storage =
(failwith "This contract always fails" : operation list * storage)

6
src/test/contracts/failwith.religo
View File

@ -1,8 +1,4 @@
type storage = unit;
let main = (p: unit, storage) =>
if (true) {
failwith("This contract always fails");
} else {
();
};
if (true) { failwith("This contract always fails"); };

12
src/test/contracts/fibo.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
(fun (f: (int * int) -> int) (x: int) (y: int) -> f (y,x))
(fun (x: int) (y: int) -> x + y)
0
1
let main (p, store : unit * storage) : operation list * storage =
let n =
(fun (f : int * int -> int) (x : int) (y : int) -> f (y,x))
(fun (x : int) (y : int) -> x + y)
0
1
in ([] : operation list), store

12
src/test/contracts/fibo2.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
(fun (f: int -> int) (_: int) (y: int) -> f y)
(fun (x: int) -> x)
0
1
let main (p : unit; store : storage) : operation list * storage =
let n =
(fun (f : int -> int) (z : int) (y : int) -> f y)
(fun (x : int) -> x)
0
1
in ([] : operation list), store

12
src/test/contracts/fibo3.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
(fun (f: int -> int -> int) (x: int) (y: int) -> f y (x+y))
(fun (x: int) (y: int) -> x + y)
0
1
let main (p, s : unit * storage) : operation list * storage =
let n =
(fun (f : int -> int -> int) (x : int) (y : int) -> f y (x+y))
(fun (x : int) (y : int) -> x + y)
0
1
in ([] : operation list), store

6
src/test/contracts/fibo4.mligo
View File

@ -1,6 +1,6 @@
type storage = unit
let main (p: unit) storage =
(fun (f: int -> int) (x: int) -> f x)
(fun (x: int) -> x)
let main (p, s : unit * storage) =
(fun (f : int -> int) (x : int) -> f x)
(fun (x : int) -> x)
1

2
src/test/contracts/for_fail.ligo
View File

@ -1,2 +1,2 @@
function main (const a: int) : int is
function main (const a : int) : int is
block { for i := 0 to 100 block { skip } } with i

8
src/test/contracts/function-shared.mligo
View File

@ -1,7 +1,5 @@
(* Test use of multiple subroutines in a CameLIGO function *)
let foo (i: int) : int = i + 20
let bar (i: int) : int = i + 50
let foobar (i: int) : int = (foo i) + (bar i)
let foo (i : int) : int = i + 20
let bar (i : int) : int = i + 50
let foobar (i : int) : int = foo i + bar i

8
src/test/contracts/function-shared.religo
View File

@ -1,7 +1,5 @@
/* Test use of multiple subroutines in a ReasonLIGO function */
let foo = (i: int): int => i + 20;
let bar = (i: int): int => i + 50;
let foobar = (i: int): int => foo(i) + bar(i);
let foo = (i : int) : int => i + 20;
let bar = (i : int) : int => i + 50;
let foobar = (i : int) : int => foo (i) + bar (i);

15
src/test/contracts/get_contract.ligo
View File

@ -1,19 +1,16 @@
type storage is unit
type return is list (operation) * storage
function cb (const s : storage) : return is
block {
const c : contract(unit) = get_contract(sender)
}
with (list [transaction(unit, 0mutez, c)], s)
function cb (const s : storage) : return is block {
const c : contract (unit) = get_contract (Tezos.sender)
} with (list [Tezos.transaction (unit, 0tez, c)], s)
function cbo (const s : unit) : return is
block {
const c : contract (unit) =
case (get_contract_opt(sender) : option(contract(unit))) of
Some (c) -> c
case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
Some (contract) -> contract
| None -> (failwith ("contract not found") : contract (unit))
end
}
with (list [transaction(unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)

24
src/test/contracts/guess_string.mligo
View File

@ -1,20 +1,22 @@
type storage = {
challenge : string;
challenge : string
}
type param = {
new_challenge : string;
attempt : string;
attempt : string
}
let attempt (p: param) storage =
(* if p.attempt <> storage.challenge then failwith "Failed challenge" else *)
type return = operation list * storage
let attempt (p, store : param * storage) : return =
(* if p.attempt <> store.challenge then failwith "Failed challenge" else *)
let contract : unit contract =
Operation.get_contract sender in
match (Tezos.get_contract_opt Tezos.sender : unit contract option) with
Some contract -> contract
| None -> (failwith "No contract" : unit contract)
in
let transfer : operation =
Operation.transaction (unit , contract , 10.00tz) in
(* TODO: no syntax for functional updates yet *)
(* let storage : storage = { storage with challenge = p.new_challenge } in *)
(* for now, rebuild the record by hand. *)
let storage : storage = { challenge = p.new_challenge }
in ([] : operation list), storage
Tezos.transaction (unit, contract, 10.00tez) in
let store : storage = {challenge = p.new_challenge}
in ([] : operation list), store

85
src/test/contracts/hashlock.mligo
View File

@ -1,56 +1,67 @@
type commit = {
date: timestamp;
salted_hash: bytes;
date : timestamp;
salted_hash : bytes;
}
type commit_set = (address, commit) big_map
type storage = {
hashed: bytes;
unused: bool;
commits: commit_set;
hashed : bytes;
unused : bool;
commits : commit_set
}
type reveal = {
hashable: bytes;
message: unit -> operation list;
hashable : bytes;
message : unit -> operation list
}
type parameter =
| Commit of bytes
Commit of bytes
| Reveal of reveal
(* We use hash-commit so that a baker can't steal *)
let commit ((p,s): bytes * storage) : operation list * storage =
let commit: commit = {date = Current.time + 86400; salted_hash = p;} in
let updated_map: commit_set = Big_map.update sender (Some commit) s.commits in
let s = {hashed = s.hashed; unused = s.unused; commits = updated_map} in
(([]: operation list), s)
type return = operation list * storage
let reveal ((p,s): reveal * storage) : operation list * storage =
(* We use hash-commit so that a baker can not steal *)
let commit (p, s : bytes * storage) : return =
let commit : commit =
{date = Tezos.now + 86_400; salted_hash = p} in
let updated_map: commit_set =
Big_map.update Tezos.sender (Some commit) s.commits in
let s = {s with commits = updated_map}
in ([] : operation list), s
let reveal (p, s : reveal * storage) : return =
if not s.unused
then (failwith "This contract has already been used.": operation list * storage)
else
let commit: commit =
match (Big_map.find_opt sender s.commits) with
| Some c -> c
| None -> (failwith "You haven't made a commitment to hash against yet.": commit)
in
if Current.time < commit.date
then (failwith "It hasn't been 24 hours since your commit yet.": operation list * storage)
else
let salted = Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
if (salted <> commit.salted_hash)
then (failwith "This reveal doesn't match your commitment.": operation list * storage)
else
if (s.hashed = Crypto.sha256 p.hashable)
then
let s: storage = {hashed = s.hashed; unused = false; commits = s.commits} in
((p.message ()), s)
else (failwith "Your commitment did not match the storage hash.":
operation list * storage)
(failwith "This contract has already been used." : return)
else
let commit : commit =
match Big_map.find_opt sender s.commits with
| Some c -> c
| None ->
(failwith "You have not made a commitment to hash against yet."
: commit)
in
if Tezos.now < commit.date
then
(failwith "It has not been 24 hours since your commit yet.": return)
else
let salted =
Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
if salted <> commit.salted_hash
then
(failwith "This reveal does not match your commitment.": return)
else
if s.hashed = Crypto.sha256 p.hashable
then
let s : storage = {s with unused = false}
in p.message (), s
else (failwith "Your commitment did not match the storage hash."
: return)
let main ((p,s): parameter * storage) : operation list * storage =
let main (p, s : parameter * storage) : return =
match p with
| Commit c -> commit (c, s)
| Reveal r -> reveal (r, s)
| Commit c -> commit (c,s)
| Reveal r -> reveal (r,s)

16
src/test/contracts/heap.ligo
View File

@ -10,8 +10,12 @@ function get_top (const h : heap) : heap_elt is get_force (1n, h)
function pop_switch (const h : heap) : heap is
block {
const result : heap_elt = get_top (h);
const s : nat = size (h);
const last : heap_elt = get_force (s, h);
const s : nat = Map.size (h);
const last : heap_elt =
case h[s] of
Some (e) -> e
| None -> (failwith ("No element.") : heap_elt)
end;
remove 1n from map h;
h[1n] := last
} with h
@ -19,8 +23,12 @@ function pop_switch (const h : heap) : heap is
function pop_ (const h : heap) : nat is
block {
const result : heap_elt = get_top (h);
const s : nat = size (h);
var current : heap_elt := get_force (s, h);
const s : nat = Map.size (h);
var current : heap_elt :=
case h[s] of
Some (e) -> e
| None -> (failwith ("No element.") : heap_elt)
end;
const i : nat = 1n;
const left : nat = 2n * i;
const right : nat = left + 1n;

40
src/test/contracts/high-order.mligo
View File

@ -1,30 +1,24 @@
(* Test a function which takes another function as an argument *)
let foobar (i : int) : int =
let foo: (int -> int) =
fun (i : int) -> i
in
let bar: ((int -> int) -> int) =
fun (f : int -> int) -> f i
in
bar foo
let foo: (int -> int) = fun (i : int) -> i in
let bar: ((int -> int) -> int) = fun (f : int -> int) -> f i
in bar foo
(* higher order function with more than one argument *)
let higher2 (i: int) (f: int -> int): int =
let higher2 (i : int) (f : int -> int): int =
let ii: int = f i in ii
let foobar2 (i : int) : int =
let foo2: (int -> int) =
fun (i : int) -> i
in
higher2 i foo2
let foo2 : (int -> int) = fun (i : int) -> i
in higher2 i foo2
let a : int = 0
let foobar3 (i : int) : int =
let foo2: (int -> int) =
fun (i : int) -> a + i
in
higher2 i foo2
let foo2 : (int -> int) = fun (i : int) -> a + i
in higher2 i foo2
let f (i : int) : int = i
@ -32,15 +26,11 @@ let g (i : int) : int = f i
let foobar4 (i : int) : int = g (g i)
let higher3 (i: int) (f: int -> int) (g: int -> int) : int =
let ii: int = f (g i) in ii
let higher3 (i : int) (f : int -> int) (g : int -> int) : int =
let ii : int = f (g i) in ii
let foobar5 (i : int) : int =
let a : int = 0 in
let foo: (int -> int) =
fun (i : int) -> a + i
in
let goo: (int -> int) =
fun (i : int) -> foo i
in
higher3 i foo goo
let foo : (int -> int) = fun (i : int) -> a + i in
let goo : (int -> int) = fun (i : int) -> foo i
in higher3 i foo goo

52
src/test/contracts/high-order.religo
View File

@ -1,48 +1,44 @@
/* Test a function which takes another function as an argument */
let foobar = (i: int): int => {
let foobar = (i : int): int => {
let foo: int => int = (i: int) => i;
let bar: ((int => int) => int) = (f: (int => int)) => f(i);
bar(foo);
let bar: ((int => int) => int) = (f : (int => int)) => f (i);
bar (foo);
};
/* higher order function with more than one argument */
let higher2 = (i: int, f: (int => int)): int => {
let ii: int = f(i);
let higher2 = (i : int, f : (int => int)) : int => {
let ii : int = f (i);
ii;
};
let foobar2 = (i: int): int => {
let foo2: int => int = (i: int) => i;
higher2(i, foo2);
let foobar2 = (i : int) : int => {
let foo2 : int => int = (i : int) => i;
higher2 (i, foo2);
};
let a: int = 0;
let a : int = 0;
let foobar3 = (i: int): int => {
let foo2: int => int = (i: int) => a + i;
higher2(i, foo2);
let foobar3 = (i : int) : int => {
let foo2: int => int = (i : int) => a + i;
higher2 (i, foo2);
};
let f = (i: int): int => i;
let f = (i : int) : int => i;
let g = (i: int): int => f(i);
let g = (i : int) : int => f (i);
let foobar4 = (i: int): int => g(g(i));
let foobar4 = (i : int) : int => g (g (i));
let higher3 = (i: int, f: (int => int), g: (int => int)): int => {
let ii: int = f(g(i));
let higher3 = (i : int, f : (int => int), g : (int => int)) : int => {
let ii : int = f (g (i));
ii;
};
let foobar5 = (i: int): int => {
let a: int = 0;
let foo: int => int = (i: int) => a + i;
let goo: int => int = (i: int) => foo(i);
higher3(i, foo, goo);
let foobar5 = (i : int) : int => {
let a : int = 0;
let foo : int => int = (i : int) => a + i;
let goo : int => int = (i : int) => foo (i);
higher3 (i, foo, goo);
};

182
src/test/contracts/id.mligo
View File

@ -3,7 +3,7 @@ type id = int
type id_details = {
owner: address;
controller: address;
profile: bytes;
profile: bytes
}
type buy = bytes * address option
@ -14,126 +14,118 @@ type action =
| Buy of buy
| Update_owner of update_owner
| Update_details of update_details
| Skip of unit
| Skip
(* The prices kept in storage can be changed by bakers, though they
should only be adjusted down over time, not up. *)
(* The prices kept in storage can be changed by bakers, though they should only be
adjusted down over time, not up. *)
type storage = (id, id_details) big_map * int * (tez * tez)
(** Preliminary thoughts on ids:
type return = operation list * storage
I very much like the simplicity of http://gurno.com/adam/mne/.
5 three letter words means you have a 15 character identity, not actually more
annoying than an IP address and a lot more memorable than the raw digits. This
can be stored as a single integer which is then translated into the corresponding
series of 5 words.
(* Preliminary thoughts on ids:
I in general like the idea of having a 'skip' mechanism, but it does need to cost
something so people don't eat up the address space. 256 ^ 5 means you have a lot
of address space, but if people troll by skipping a lot that could be eaten up.
Should probably do some napkin calculations for how expensive skipping needs to
be to deter people from doing it just to chew up address space.
*)
I very much like the simplicity of http://gurno.com/adam/mne/. 5 three
letter words means you have a 15 character identity, not actually more
annoying than an IP address and a lot more memorable than the raw
digits. This can be stored as a single integer which is then
translated into the corresponding series of 5 words.
I in general like the idea of having a 'skip' mechanism, but it does
need to cost something so people don't eat up the address space. 256^5
means you have a lot of address space, but if people troll by skipping
a lot that could be eaten up. Should probably do some napkin
calculations for how expensive skipping needs to be to deter people
from doing it just to chew up address space. *)
let buy (parameter, storage: (bytes * address option) * storage) =
let void: unit =
if amount = storage.2.0
then ()
else (failwith "Incorrect amount paid.": unit)
in
let void : unit =
if Tezos.amount <> storage.2.0
then (failwith "Incorrect amount paid.": unit) in
let profile, initial_controller = parameter in
let identities, new_id, prices = storage in
let controller: address =
let controller : address =
match initial_controller with
| Some addr -> addr
| None -> sender
in
| None -> sender in
let new_id_details: id_details = {
owner = sender ;
controller = controller ;
profile = profile ;
}
in
let updated_identities: (id, id_details) big_map =
owner = sender;
controller = controller;
profile = profile} in
let updated_identities : (id, id_details) big_map =
Big_map.update new_id (Some new_id_details) identities
in
([]: operation list), (updated_identities, new_id + 1, prices)
in ([]: operation list), (updated_identities, new_id + 1, prices)
let update_owner (parameter, storage: (id * address) * storage) =
if (amount <> 0mutez)
then (failwith "Updating owner doesn't cost anything.": (operation list) * storage)
let update_owner (parameter, storage : (id * address) * storage) =
if amount <> 0tez
then (failwith "Updating owner doesn't cost anything.": return)
else
let id, new_owner = parameter in
let identities, last_id, prices = storage in
let current_id_details: id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist.": id_details)
in
let is_allowed: bool =
if sender = current_id_details.owner
then true
else (failwith "You are not the owner of this ID.": bool)
in
let updated_id_details: id_details = {
let id, new_owner = parameter in
let identities, last_id, prices = storage in
let current_id_details : id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist." : id_details) in
let is_allowed : bool =
if Tezos.sender = current_id_details.owner
then true
else (failwith "You are not the owner of this ID." : bool) in
let updated_id_details : id_details = {
owner = new_owner;
controller = current_id_details.controller;
profile = current_id_details.profile;
}
in
let updated_identities = Big_map.update id (Some updated_id_details) identities in
([]: operation list), (updated_identities, last_id, prices)
profile = current_id_details.profile} in
let updated_identities =
Big_map.update id (Some updated_id_details) identities
in ([]: operation list), (updated_identities, last_id, prices)
let update_details (parameter, storage: (id * bytes option * address option) * storage) =
if (amount <> 0mutez)
then (failwith "Updating details doesn't cost anything.": (operation list) * storage)
if Tezos.amount <> 0tez
then
(failwith "Updating details doesn't cost anything." : return)
else
let id, new_profile, new_controller = parameter in
let identities, last_id, prices = storage in
let current_id_details: id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist.": id_details)
in
let is_allowed: bool =
if (sender = current_id_details.controller) || (sender = current_id_details.owner)
then true
else (failwith ("You are not the owner or controller of this ID."): bool)
in
let owner: address = current_id_details.owner in
let profile: bytes =
match new_profile with
| None -> (* Default *) current_id_details.profile
| Some new_profile -> new_profile
in
let controller: address =
match new_controller with
| None -> (* Default *) current_id_details.controller
| Some new_controller -> new_controller
in
let updated_id_details: id_details = {
owner = owner;
controller = controller;
profile = profile;
}
in
let id, new_profile, new_controller = parameter in
let identities, last_id, prices = storage in
let current_id_details: id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist.": id_details) in
let is_allowed : bool =
if Tezos.sender = current_id_details.controller
|| Tezos.sender = current_id_details.owner
then true
else
(failwith ("You are not the owner or controller of this ID.")
: bool) in
let owner : address = current_id_details.owner in
let profile : bytes =
match new_profile with
| None -> (* Default *) current_id_details.profile
| Some new_profile -> new_profile in
let controller : address =
match new_controller with
| None -> (* Default *) current_id_details.controller
| Some new_controller -> new_controller in
let updated_id_details: id_details = {
owner = owner;
controller = controller;
profile = profile} in
let updated_identities: (id, id_details) big_map =
Big_map.update id (Some updated_id_details) identities in
([]: operation list), (updated_identities, last_id, prices)
Big_map.update id (Some updated_id_details) identities
in ([]: operation list), (updated_identities, last_id, prices)
(* Let someone skip the next identity so nobody has to take one that's undesirable *)
let skip (p,storage: unit * storage) =
let void: unit =
if amount = storage.2.1
then ()
else (failwith "Incorrect amount paid.": unit)
in
(* Let someone skip the next identity so nobody has to take one that's
undesirable *)
let skip (p, storage: unit * storage) =
let void : unit =
if Tezos.amount <> storage.2.1
then (failwith "Incorrect amount paid." : unit) in
let identities, last_id, prices = storage in
([]: operation list), (identities, last_id + 1, prices)
let main (action, storage: action * storage) : operation list * storage =
let main (action, storage : action * storage) : return =
match action with
| Buy b -> buy (b, storage)
| Update_owner uo -> update_owner (uo, storage)
| Update_details ud -> update_details (ud, storage)
| Skip s -> skip ((), storage)
| Skip -> skip ((), storage)

6
src/test/contracts/implicit.mligo
View File

@ -1,5 +1,5 @@
let main2 (p : key_hash) (s : unit) =
let c : unit contract = Current.implicit_account p in
(([] : operation list), unit)
let c : unit contract = Tezos.implicit_account p
in ([] : operation list), unit
let main (t: key_hash * unit) = main2 t.0 t.1
let main (p,s : key_hash * unit) = main2 p s

3
src/test/contracts/implicit_account.ligo
View File

@ -1 +1,2 @@
function main (const kh: key_hash) : contract (unit) is implicit_account (kh)
function main (const kh: key_hash) : contract (unit) is
Tezos.implicit_account (kh)

2
src/test/contracts/implicit_account.mligo
View File

@ -1 +1 @@
let main (kh: key_hash) : unit contract = Current.implicit_account kh
let main (kh : key_hash) : unit contract = Tezos.implicit_account kh

3
src/test/contracts/implicit_account.religo
View File

@ -1 +1,2 @@
let main = (kh: key_hash): contract(unit) => Current.implicit_account(kh);
let main = (kh : key_hash) : contract (unit) =>
Tezos.implicit_account (kh);

18
src/test/contracts/incr_decr.mligo
View File

@ -1,19 +1,17 @@
type storage = int
(* variant defining pseudo multi-entrypoint actions *)
type action =
type parameter =
Increment of int
| Decrement of int
let add (a: int) (b: int) : int = a + b
let sub (a: int) (b: int) : int = a - b
type return = operation list * storage
(* real entrypoint that re-routes the flow based on the action provided *)
let add (a : int) (b : int) : int = a + b
let sub (a : int) (b : int) : int = a - b
let main (p: action) storage =
let storage =
match p with
let main (action, store : parameter * storage) : return =
let store =
match action with
Increment n -> add s n
| Decrement n -> sub s n
in ([] : operation list), storage
in ([] : operation list), store

218
src/test/contracts/interpret_test.mligo
View File

@ -1,87 +1,87 @@
let lambda_call =
let a = 3 in
let foo = fun (i : int) -> i * i in
foo (a + 1)
let foo = fun (i : int) -> i * i
in foo (a + 1)
let higher_order1 =
let a = 2 in
let foo = fun (i:int) (j:int) (k:int) ->
a + i + j + 0 in
let bar = (foo 1 2) in
bar 3
let foo = fun (i : int) (j : int) (k : int) -> a + i + j + 0 in
let bar = (foo 1 2)
in bar 3
let higher_order2 =
let a = 2 in
let foo = fun (i:int) ->
let b = 2 in
let bar = fun (i:int) -> i + a + b
in bar i
let foo = fun (i : int) ->
let b = 2 in
let bar = fun (i : int) -> i + a + b
in bar i
in foo 1
let higher_order3 =
let foo = fun (i:int) -> i + 1 in
let bar = fun (f:int->int) (i:int) -> (f i) + 1 in
let baz : (int -> int ) = bar foo in
baz 3
let foo = fun (i : int) -> i + 1 in
let bar = fun (f : int -> int) (i : int) -> f i + 1 in
let baz : int -> int = bar foo
in baz 3
let higher_order4 =
let a = 3 in
let foo = fun (i : int) -> a + i in
let bar: (int -> int) = fun (i : int) -> foo i in
bar 2
let concats =
0x70 ^ 0x70
let bar : int -> int = fun (i : int) -> foo i
in bar 2
let concats = 0x70 ^ 0x70
type foo_record = {
a : string ;
b : string ;
a : string;
b : string
}
let record_concat =
let ab : foo_record = { a = "a" ; b = "b" } in
ab.a ^ ab.b
let ab : foo_record = {a="a"; b="b"}
in ab.a ^ ab.b
let record_patch =
let ab : foo_record = { a = "a" ; b = "b" } in
{ab with b = "c"}
let ab : foo_record = {a="a"; b="b"}
in {ab with b = "c"}
type bar_record = {
f : int -> int ;
arg : int ;
f : int -> int;
arg : int
}
let record_lambda =
let a = 1 in
let foo : (int -> int) = fun (i:int) -> a+(i*2) in
let farg : bar_record = { f = foo ; arg = 2 } in
farg.f farg.arg
let foo : int -> int = fun (i : int) -> a + i*2 in
let farg : bar_record = {f = foo; arg = 2}
in farg.f farg.arg
type foo_variant =
| Foo
| Bar of int
| Baz of string
let variant_exp =
(Foo, Bar 1, Baz "b")
let variant_exp = Foo, Bar 1, Baz "b"
let variant_match =
let a = Bar 1 in
match a with
| Foo -> 1
| Bar(i) -> 2
| Baz(s) -> 3
| Foo -> 1
| Bar i -> 2
| Baz s -> 3
/* UNSUPPORTED
(* UNSUPPORTED: No deep patterns yet.
type bar_variant =
| Baz
| Buz of int * int
| Biz of int * int * string
let long_variant_match =
let a = Biz (1,2,"Biz") in
match a with
| Baz -> "Baz"
| Buz(a,b) -> "Buz"
| Biz(a,b,c) -> c
*/
| Buz (a,b) -> "Buz"
| Biz (a,b,c) -> c
*)
let bool_match =
let b = true in
@ -90,149 +90,145 @@ let bool_match =
| false -> 2
let list_match =
let a = [ 1 ; 2 ; 3 ; 4 ] in
let a = [1; 2; 3; 4] in
match a with
| hd :: tl -> hd::a
| hd::tl -> hd::a
| [] -> a
let tuple_proj =
let (a,b) = (true,false) in
a or b
let a, b = true, false
in a or b
let list_const =
let a = [1 ; 2 ; 3 ; 4] in
0 :: a
let a = [1; 2; 3; 4]
in 0::a
type foobar = int option
let options_match_some =
let a = Some 0 in
match a with
| Some(i) -> i
| Some i -> i
| None -> 1
let options_match_none =
let a : foobar = None in
match a with
| Some(i) -> i
| Some i -> i
| None -> 0
let is_nat_nat =
let i : int = 1 in
let j : int = -1 in
(Michelson.is_nat i, Michelson.is_nat j)
let j : int = -1
in is_nat i, is_nat j
let abs_int = abs (-5)
let nat_int = int (5n)
let nat_int = int 5n
let map_list =
let a = [1 ; 2 ; 3 ; 4] in
let add_one: (int -> int) = fun (i : int) -> i + 1 in
List.map add_one a
let a = [1; 2; 3; 4] in
let add_one : (int -> int) = fun (i : int) -> i + 1
in List.map add_one a
let fail_alone = failwith "you failed"
let iter_list_fail =
let a = [1 ; 2 ; 3 ; 4] in
let check_something: (int -> unit) = fun (i : int) ->
if i = 2 then failwith "you failed"
else ()
in
List.iter check_something a
let a = [1; 2; 3; 4] in
let check_something : int -> unit =
fun (i : int) ->
if i = 2 then failwith "you failed"
in List.iter check_something a
let fold_list =
let a = [1 ; 2 ; 3 ; 4] in
let acc : (int * int -> int) =
fun (prev, el : int * int) -> prev + el in
List.fold acc a 0
let a = [1; 2; 3; 4] in
let acc : int * int -> int =
fun (prev, el : int * int) -> prev + el
in List.fold acc a 0
let comparison_int =
(1 > 2, 2 > 1, 1 >=2 , 2 >= 1)
let comparison_int = 1 > 2, 2 > 1, 1 >=2, 2 >= 1
let comparison_string =
("foo" = "bar", "baz" = "baz")
let comparison_string = "foo"="bar", "baz"="baz"
let divs : (int * nat * tez * nat) =
(1/2 , 1n/2n , 1tz/2n , 1tz/2tz)
let divs : int * nat * tez * nat = 1/2, 1n/2n, 1tez/2n, 1tez/2tez
let var_neg =
let a = 2 in
-a
let a = 2 in -a
let sizes =
let a = [ 1 ; 2 ; 3 ; 4 ; 5 ] in
let a = [1; 2; 3; 4; 5] in
let b = "12345" in
let c = Set.literal [ 1 ; 2 ; 3 ; 4 ; 5 ] in
let d = Map.literal [ (1,1) ; (2,2) ; (3,3) ] in
let c = Set.literal [1; 2; 3; 4; 5] in
let d = Map.literal [(1,1); (2,2); (3,3)] in
let e = 0xFFFF in
(List.size a, String.size b, Set.size c, Map.size d, Bytes.size e)
List.length a,
String.length b,
Set.cardinal c,
Map.size d,
Bytes.length e
let modi = 3 mod 2
let fold_while =
let aux : int -> bool * int = fun (i:int) ->
if i < 10 then continue (i + 1) else stop i in
(Loop.fold_while aux 20, Loop.fold_while aux 0)
let aux : int -> bool * int =
fun (i : int) ->
if i < 10 then Loop.resume (i + 1) else Loop.stop i
in (Loop.fold_while aux 20, Loop.fold_while aux 0)
let assertion_pass =
assert (1=1)
let assertion_pass = assert (1=1)
let assertion_fail =
assert (1=2)
let assertion_fail = assert (1=2)
let lit_address = ("KT1ThEdxfUcWUwqsdergy3QnbCWGHSUHeHJq" : address)
let map_finds =
let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
Map.find_opt "two" m
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
in Map.find_opt "two" m
let map_finds_fail =
let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
Map.find "four" m
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
in Map.find "four" m
let map_empty =
((Map.empty : (int,int) map) , (Map.literal [] : (int,int) map))
((Map.empty : (int, int) map), (Map.literal [] : (int, int) map))
let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ]
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
let map_fold =
let aux = fun (i: int * (string * int)) -> i.0 + i.1.1 in
Map.fold aux m (-2)
let aux = fun (i : int * (string * int)) -> i.0 + i.1.1
in Map.fold aux m (-2)
let map_iter =
let aux = fun (i: string * int) -> if (i.1=12) then failwith "never" else () in
Map.iter aux m
let aux =
fun (i : string * int) -> if i.1 = 12 then failwith "never"
in Map.iter aux m
let map_map =
let aux = fun (i: string * int) -> i.1 + (String.size i.0) in
Map.map aux m
let aux = fun (i : string * int) -> i.1 + String.length i.0
in Map.map aux m
let map_mem = (Map.mem "one" m , Map.mem "four" m)
let map_mem = Map.mem "one" m, Map.mem "four" m
let map_remove = (Map.remove "one" m, Map.remove "four" m)
let map_remove = Map.remove "one" m, Map.remove "four" m
let map_update = (
Map.update "one" (Some(1)) (Map.literal [ "one", 2 ]),
Map.update "one" (None : int option) (Map.literal [ "one", 1]),
Map.update "one" (None : int option) (Map.literal []:(string,int) map),
Map.update "one" (Some(1)) (Map.literal []:(string,int) map)
)
let map_update =
Map.update "one" (Some 1) (Map.literal ["one", 2]),
Map.update "one" (None : int option) (Map.literal ["one", 1]),
Map.update "one" (None : int option) (Map.empty : (string, int) map),
Map.update "one" (Some 1) (Map.literal [] : (string, int) map)
let s = Set.literal [ 1 ; 2 ; 3 ]
let s = Set.literal [1; 2; 3]
let set_add = (
let set_add =
Set.add 1 s,
Set.add 4 s,
Set.add 1 (Set.literal [] : int set)
)
Set.add 1 (Set.empty : int set)
let set_iter_fail =
let aux = fun (i:int) -> if i = 1 then failwith "set_iter_fail" else () in
Set.iter aux (Set.literal [1 ; 2 ; 3])
let aux = fun (i : int) -> if i = 1 then failwith "set_iter_fail"
in Set.iter aux (Set.literal [1; 2; 3])
let set_mem = (
let set_mem =
Set.mem 1 s,
Set.mem 4 s,
Set.mem 1 (Set.literal [] : int set)
)
Set.mem 1 (Set.empty : int set)

2
src/test/contracts/isnat.mligo
View File

@ -1 +1 @@
let main (i: int) : nat option = Michelson.is_nat i
let main (i : int) : nat option = is_nat i

2
src/test/contracts/isnat.religo
View File

@ -1 +1 @@
let main = (i: int): option(nat) => Michelson.is_nat(i);
let main = (i : int): option (nat) => is_nat (i);

6
src/test/contracts/key_hash.ligo
View File

@ -1,7 +1,5 @@
function check_hash_key (const kh1 : key_hash;
const k2 : key) : bool * key_hash is
block {
var ret : bool := False;
var kh2 : key_hash := crypto_hash_key (k2);
if kh1 = kh2 then ret := True else skip
} with (ret, kh2)
var kh2 : key_hash := Crypto.hash_key (k2);
} with ((kh1 = kh2), kh2)

8
src/test/contracts/key_hash.mligo
View File

@ -1,5 +1,3 @@
let check_hash_key (kh1, k2: key_hash * key) : bool * key_hash =
let kh2 : key_hash = Crypto.hash_key k2 in
if kh1 = kh2
then (true, kh2)
else (false, kh2)
let check_hash_key (kh1, k2 : key_hash * key) : bool * key_hash =
let kh2 : key_hash = Crypto.hash_key k2
in kh1 = kh2, kh2

11
src/test/contracts/key_hash.religo
View File

@ -1,10 +1,5 @@
let check_hash_key = (kh1_k2: (key_hash, key)) : (bool, key_hash) => {
let check_hash_key = (kh1_k2 : (key_hash, key)) : (bool, key_hash) => {
let kh1, k2 = kh1_k2;
let kh2 : key_hash = Crypto.hash_key(k2);
if (kh1 == kh2) {
(true, kh2);
}
else {
(false, kh2);
}
let kh2 : key_hash = Crypto.hash_key (k2);
((kh1 == kh2), kh2)
};

11
src/test/contracts/key_hash_comparable.ligo
View File

@ -1,8 +1,9 @@
type storage is record
one: map(key_hash, nat);
two: big_map(key_hash, bool);
end
type storage is record [
one : map (key_hash, nat);
two : big_map (key_hash, bool)
]
type return is list (operation) * storage
function main (const a : int; const store : storage) : return is ((nil: list(operation)), store)
function main (const a : int; const store : storage) : return is
((nil : list (operation)), store)

5
src/test/contracts/lambda.mligo
View File

@ -1,8 +1,7 @@
type storage = unit
(* not supported yet
let main (p:unit) storage =
(fun x -> ()) ()
let main (p, s : unit * storage) = (fun x -> ()) ()
*)
let main (ps: unit * storage) = (fun (_: unit) -> ()) ()
let main (p, s : unit * storage) = (fun (_ : unit) -> ()) ()

5
src/test/contracts/lambda.religo
View File

@ -5,6 +5,5 @@ type storage = unit;
(fun x -> ()) ()
*/
let main2 = ((p: unit), s: storage) => (((xxx: unit)) => ())();
let main = (x: (unit, storage)) => main2(x[0], x[1]);
let main = ((p,s) : (unit, storage)) : unit =>
(((useless : unit)) => ()) ();

6
src/test/contracts/lambda2.mligo
View File

@ -1,8 +1,8 @@
type storage = unit
(* Not supported yet:
let main (p:unit) storage = (fun x -> ()) ()
let main (a, s : unit * storage) = (fun x -> ()) ()
*)
let main (_: unit * storage) =
(fun (f: unit -> unit) -> f ()) (fun (_: unit) -> unit)
let main (a, s : unit * storage) =
(fun (f : unit -> unit) -> f ()) (fun (_ : unit) -> unit)

6
src/test/contracts/lambda2.religo
View File

@ -4,7 +4,5 @@ type storage = unit;
let main (p:unit) storage = (fun x -> ()) ()
*/
let main2 = (z: unit, s: storage) =>
((f: (unit => unit)) => f())((z: unit) => unit);
let main = (x: (unit, storage)) => main2(x[0],x[1]);
let main = ((a, s) : (unit, storage)) : unit =>
((f : (unit => unit)) => f ()) ((useless : unit) => unit);

2
src/test/contracts/let_in_multi_bind.mligo
View File

@ -1,4 +1,4 @@
let sum (p: int * int) : int =
let sum (p : int * int) : int =
let i, result = p in i + result
let sum2 (p: string * string * string * string) : string =

24
src/test/contracts/let_multiple.mligo
View File

@ -1,38 +1,36 @@
(* Simple test of binding multiple values *)
let (x: int), (y: int) = 1,2
let (x : int), (y : int) = 1,2
let main (p: unit) : int = x + y
let main (p : unit) : int = x + y
let ((x : int) , (y :int)) = 3,3
let ((x : int) , (y : int)) = 3,3
let main_paren (p: unit) : int = x + y
let main_paren (p : unit) : int = x + y
let foobar : (int * int) = (23 , 42)
let (foo : int) , (bar : int) = foobar
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let correct_values_bound (p: unit) : int * int =
foo, bar
let correct_values_bound (p : unit) : int * int = foo, bar
let non_tuple_rhs (p: unit) : int =
bar - foo
let non_tuple_rhs (p : unit) : int = bar - foo
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let big_tuple : (int * int * int * int * int) = (10, 20, 30, 40, 50)
let big_tuple : int * int * int * int * int = 10, 20, 30, 40, 50
let (a: int), (b: int), (c: int), (d: int), (e: int) = big_tuple
let correct_values_big_tuple (p: unit) : int * int * int * int * int =
let correct_values_big_tuple (p : unit) : int * int * int * int * int =
a, b, c, d, e
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let different_types: (int * string) = 10, "hello"
let different_types : int * string = 10, "hello"
let (greet_num: int), (greeting: string) = different_types
let (greet_num : int), (greeting : string) = different_types
let correct_values_different_types (p: unit) : int * string =
let correct_values_different_types (p : unit) : int * string =
greet_num, greeting

15
src/test/contracts/let_multiple.religo
View File

@ -1,14 +1,15 @@
/* Simple test of binding multiple values */
let ((x: int), (y: int)) = (1, 2);
let ((x : int), (y : int)) = (1,2);
let main = (p: unit): int => x + y;
let main = (p : unit): int => x + y;
let ((x: int), (y: int)) = (3, 3);
let ((x : int), (y : int)) = (3,3);
let main_paren = (p: unit): int => x + y;
let main_paren = (p : unit): int => x + y;
let foobar: (int, int) = (23, 42);
let ((foo: int), (bar: int)) = foobar;
let foobar : (int, int) = (23, 42);
let non_tuple_rhs = (p: unit): int => foo + bar;
let ((foo : int), (bar : int)) = foobar;
let non_tuple_rhs = (p : unit) : int => foo + bar;

2
src/test/contracts/letin.mligo
View File

@ -1,6 +1,6 @@
type storage = int * int
let main (n: int * storage) =
let main (n : int * storage) : operation list * storage =
let x : int * int =
let x : int = 7
in x + n.0, n.1.0 + n.1.1

12
src/test/contracts/letin.religo
View File

@ -1,11 +1,9 @@
type storage = (int, int);
let main2 = ((n : int), s: storage) => {
let x: (int, int) = {
let x: int = 7;
(x + n, s[0] + s[1]);
let main = (n : (int, storage)) : (list (operation), storage) => {
let x : (int, int) = {
let x : int = 7;
(x + n[0], n[1][0] + n[1][1]);
};
([]: list(operation), x);
([]: list (operation), x);
};
let main = (x: (int, storage)) => main2(x[0],x[1]);

6
src/test/contracts/list.ligo
View File

@ -17,17 +17,17 @@ const bl : foobar = list [144; 51; 42; 120; 421]
function fold_op (const s : list (int)) : int is
block {
function aggregate (const prec: int; const cur: int) : int is prec+cur
} with list_fold (aggregate, s, 10)
} with List.fold (aggregate, s, 10)
function iter_op (const s : list (int)) : int is
block {
var r : int := 0;
function aggregate (const i : int) : unit is
block { r := r + i } with unit;
list_iter (aggregate, s)
List.iter (aggregate, s)
} with r
function map_op (const s : list (int)) : list (int) is
block {
function increment (const i : int) : int is i+1
} with list_map (increment, s)
} with List.map (increment, s)

18
src/test/contracts/list.mligo
View File

@ -1,27 +1,29 @@
type storage = int * int list
type param = int list
type parameter = int list
type return = operation list * storage
let x : int list = []
let y : int list = [3; 4; 5]
let z : int list = 2::y
let main (p, s: param * storage) =
let main (p, s: parameter * storage) : return =
let storage =
match p with
[] -> s
| hd::tl -> s.0 + hd, tl
in ([] : operation list), storage
let size_ (s: int list) : nat = List.size s
let size_ (s : int list) : nat = List.length s
let fold_op (s: int list) : int =
let aggregate = fun (t: int * int) -> t.0 + t.1
let fold_op (s : int list) : int =
let aggregate = fun (t : int * int) -> t.0 + t.1
in List.fold aggregate s 10
let map_op (s: int list) : int list =
List.map (fun (cur: int) -> cur + 1) s
let map_op (s : int list) : int list =
List.map (fun (cur : int) -> cur + 1) s
let iter_op (s : int list) : unit =
let do_nothing = fun (_: int) -> unit
let do_nothing = fun (_ : int) -> unit
in List.iter do_nothing s

40
src/test/contracts/list.religo
View File

@ -1,33 +1,33 @@
type storage = (int, list(int));
type storage = (int, list (int));
type param = list(int);
type parameter = list (int);
let x: list(int) = [];
let y: list(int) = [3, 4, 5];
let z: list(int) = [2, ...y];
type return = (list (operation), storage);
let main2 = (p: param, storage : storage) => {
let x : list (int) = [];
let y : list (int) = [3, 4, 5];
let z : list (int) = [2, ...y];
let main = ((action, s) : (parameter, storage)) : return => {
let storage =
switch (p) {
| [] => storage
| [hd, ...tl] => (storage[0] + hd, tl)
switch (action) {
| [] => s
| [hd, ...tl] => (s[0] + hd, tl)
};
([]: list(operation), storage);
};
let main = (x: (param, storage)) => main2(x[0],x[1]);
let size_ = (s : list (int)) : nat => List.length (s);
let size_ = (s: list(int)): nat => List.size(s);
let fold_op = (s: list(int)): int => {
let aggregate = (prec_cur: (int, int)) => prec_cur[0] + prec_cur[1];
List.fold(aggregate, s, 10);
let fold_op = (s : list (int)) : int => {
let aggregate = (t: (int, int)) => t[0] + t[1];
List.fold (aggregate, s, 10);
};
let map_op = (s: list(int)): list(int) =>
List.map((cur: int) => cur + 1, s);
let map_op = (s : list (int)) : list (int) =>
List.map ((cur : int) => cur + 1, s);
let iter_op = (s: list(int)): unit => {
let do_nothing = (z: int) => unit;
List.iter(do_nothing, s);
let iter_op = (s : list (int)) : unit => {
let do_nothing = (useless : int) => unit;
List.iter (do_nothing, s);
};

Some files were not shown because too many files have changed in this diff Show More