Merge branch 'master' into radrow-patch-2

Update CHANGELOG.md
Merge pull request #138 from aeternity/aens-at-full-node-ver-ta
2019-09-02 12:09:53 +02:00 · 2019-09-02 12:08:01 +02:00 · 2019-09-02 11:07:59 +02:00 · 2019-09-02 10:21:35 +02:00 · 2019-09-02 09:56:56 +02:00 · 2019-09-02 08:54:38 +02:00
33 changed files with 747 additions and 590 deletions
@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]
 ### Added
+- Standard library support. `ListInternal` can be included implicitly if list comprehensions are used.
+- Added the `[a..b]` language construct, returning the list of numbers between
+  `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
 ### Changed
 ### Removed

@@ -0,0 +1,46 @@
+namespace Func =
+
+  function id(x : 'a) : 'a = x
+
+  function const(x : 'a) : 'b => 'a = (y) => x
+
+  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
+
+  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
+
+  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
+
+  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
+
+  /* The Z combinator - replacement for local and anonymous recursion.
+   */
+  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
+    (x) => f(recur(f), x)
+
+  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
+  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
+    if(n == 0) acc
+    elif(n == 1) comp(f, acc)
+    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
+
+  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
+    (x) => (y) => f(x, y)
+  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
+    (x) => (y) => (z) => f(x, y, z)
+
+  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
+    (x, y) => f(x)(y)
+  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f(x)(y)(z)
+
+  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
+    (t) => switch(t)
+      (x, y) => f(x, y)
+  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
+    (t) => switch(t)
+      (x, y, z) => f(x, y, z)
+
+  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
+    (x, y) => f((x, y))
+  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f((x, y, z))
@@ -0,0 +1,214 @@
+include "ListInternal.aes"
+
+namespace List =
+
+  function is_empty(l : list('a)) : bool = switch(l)
+    [] => true
+    _  => false
+
+  function first(l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::_ => Some(h)
+
+  function tail(l : list('a)) : option(list('a)) = switch(l)
+    []   => None
+    _::t => Some(t)
+
+  function last(l : list('a)) : option('a) = switch(l)
+    []  => None
+    [x] => Some(x)
+    _::t => last(t)
+
+  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::t => if(p(h)) Some(h) else find(p, t)
+
+  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+  private function find_indices_( p : 'a => bool
+                                , l : list('a)
+                                , n : int
+                                , acc : list(int)
+                                ) : list(int) = switch(l)
+    []   => reverse(acc)
+    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+
+  function nth(n : int, l : list('a)) : option('a) =
+    switch(l)
+      []   => None
+      h::t => if(n == 0) Some(h) else nth(n-1, t)
+
+  /* Unsafe version of `nth` */
+  function get(n : int, l : list('a)) : 'a =
+    switch(l)
+      [] => abort(if(n < 0) "Negative index get" else "Out of index get")
+      h::t => if(n == 0) h else get(n-1, t)
+
+
+  function length(l : list('a)) : int = length_(l, 0)
+  private function length_(l : list('a), acc : int) : int = switch(l)
+    []   => acc
+    _::t => length_(t, acc + 1)
+
+
+  function from_to(a : int, b : int) : list(int) = [a..b]
+
+  function from_to_step(a : int, b : int, s : int) : list(int) = from_to_step_(a, b, s, [])
+  private function from_to_step_(a, b, s, acc) =
+    if (a > b) reverse(acc) else from_to_step_(a + s, b, s, a :: acc)
+
+
+  /* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
+  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
+    if(n<0) abort("insert_at underflow") else replace_at_(n, e, l, [])
+  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   switch(l)
+     []   => abort("replace_at overflow")
+     h::t => if (n == 0) reverse(e::acc) ++ t
+             else replace_at_(n-1, e, t, h::acc)
+
+  /* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
+  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
+    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l, [])
+  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   if (n == 0) reverse(e::acc) ++ l
+   else switch(l)
+     []   => abort("insert_at overflow")
+     h::t => insert_at_(n-1, e, t, h::acc)
+
+  function insert_by(cmp : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
+    insert_by_(cmp, x, l, [])
+  private function insert_by_(cmp : (('a, 'a) => bool), x : 'a, l : list('a), acc : list('a)) : list('a) =
+    switch(l)
+      []   => reverse(x::acc)
+      h::t =>
+        if(cmp(x, h)) // x < h
+          reverse(acc) ++ (x::l)
+        else
+          insert_by_(cmp, x, t, h::acc)
+
+
+  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
+    []   => nil
+    h::t => cons(h, foldr(cons, nil, t))
+
+  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
+    []   => acc
+    h::t => foldl(rcons, rcons(acc, h), t)
+
+  function foreach(l : list('a), f : 'a => unit) : unit =
+    switch(l)
+     []    => ()
+     e::l' =>
+       f(e)
+       foreach(l', f)
+
+  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+
+  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
+  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
+    []   => reverse(acc)
+    h::t => map_(f, t, f(h)::acc)
+
+  function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
+    ListInternal.flat_map(f, l)
+
+  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
+  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+
+  /* Take `n` first elements */
+  function take(n : int, l : list('a)) : list('a) =
+    if(n < 0) abort("Take negative number of elements") else take_(n, l, [])
+  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
+    if(n == 0) reverse(acc)
+    else switch(l)
+      []   => reverse(acc)
+      h::t => take_(n-1, t, h::acc)
+
+  /* Drop `n` first elements */
+  function drop(n : int, l : list('a)) : list('a) =
+   if(n < 0) abort("Drop negative number of elements")
+   elif (n == 0) l
+   else switch(l)
+      []   => []
+      h::t => drop(n-1, t)
+
+  /* Get the longest prefix of a list in which every element matches predicate `p` */
+  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
+  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+
+  /* Drop elements from `l` until `p` holds */
+  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => if(p(h)) drop_while(p, t) else l
+
+  /* Splits list into two lists of elements that respectively match and don't match predicate `p` */
+  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
+  private function partition_( p : 'a => bool
+                             , l : list('a)
+                             , acc_t : list('a)
+                             , acc_f : list('a)
+                             ) : (list('a) * list('a)) = switch(l)
+    []   => (reverse(acc_t), reverse(acc_f))
+    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+
+
+  function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+
+  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => true
+    h::t => if(p(h)) all(p, t) else false
+
+  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => false
+    h::t => if(p(h)) true else any(p, t)
+
+  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
+
+  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
+
+
+  /* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
+  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
+  private function zip_with_( f : ('a, 'b) => 'c
+                            , l1 : list('a)
+                            , l2 : list('b)
+                            , acc : list('c)
+                            ) : list('c) = switch ((l1, l2))
+    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
+    _ => reverse(acc)
+
+  /* Zips two lists into list of pairs. Drops longer tail. */
+  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
+
+  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
+  private function unzip_( l     : list('a * 'b)
+                         , acc_l : list('a)
+                         , acc_r : list('b)
+                         ) : (list('a) * list('b)) = switch(l)
+    []               => (reverse(acc_l), reverse(acc_r))
+    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+
+
+  // TODO: Improve?
+  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => switch (partition((x) => lesser_cmp(x, h), t))
+      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
+
+
+  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
+  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    [e]  => reverse(e::acc)
+    h::t => intersperse_(delim, t, delim::h::acc)
+
+
+  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
+  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
+    []   => reverse(acc)
+    h::t => enumerate_(t, n + 1, (n, h)::acc)
+
@@ -0,0 +1,16 @@
+namespace ListInternal =
+
+  // -- Flatmap ----------------------------------------------------------------
+
+  function flat_map(f : 'a => list('b), xs : list('a)) : list('b) =
+    switch(xs)
+      []      => []
+      x :: xs => f(x) ++ flat_map(f, xs)
+
+  // -- From..to ---------------------------------------------------------------
+
+  function from_to(a : int, b : int) : list(int) = from_to_(a, b, [])
+
+  private function from_to_(a, b, acc) =
+    if (a > b) acc else from_to_(a, b - 1, b :: acc)
+
@@ -0,0 +1,76 @@
+include "List.aes"
+
+namespace Option =
+
+  function is_none(o : option('a)) : bool = switch(o)
+    None => true
+    Some(_) => false
+
+  function is_some(o : option('a)) : bool = switch(o)
+    None => false
+    Some(_) => true
+
+
+  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
+    None => n
+    Some(x) => s(x)
+
+  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
+
+  function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
+
+  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
+
+  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => Some(f(x))
+
+  function map2(f : ('a, 'b) => 'c
+               , o1 : option('a)
+               , o2 : option('b)
+               ) : option('c) = switch((o1, o2))
+    (Some(x1), Some(x2)) => Some(f(x1, x2))
+    _ => None
+
+  function map3( f : ('a, 'b, 'c) => 'd
+               , o1 : option('a)
+               , o2 : option('b)
+               , o3 : option('c)
+               ) : option('d) = switch((o1, o2, o3))
+    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
+    _ => None
+
+  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
+    (Some(ff), Some(xx)) => Some(ff(xx))
+    _ => None
+
+  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => f(x)
+
+
+  function to_list(o : option('a)) : list('a) = switch(o)
+    None => []
+    Some(x) => [x]
+
+  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
+  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
+    []         => List.reverse(acc)
+    None::t    => filter_options_(t, acc)
+    Some(x)::t => filter_options_(t, x::acc)
+
+  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
+  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
+    []         => Some(List.reverse(acc))
+    None::t    => None
+    Some(x)::t => seq_options_(t, x::acc)
+
+
+  function choose(o1 : option('a), o2 : option('a)) : option('a) =
+    if(is_some(o1)) o1 else o2
+
+  function choose_first(l : list(option('a))) : option('a) = switch(l)
+    [] => None
+    None::t    => choose_first(t)
+    Some(x)::_ => Some(x)
+
@@ -0,0 +1,20 @@
+namespace Pair =
+
+  function fst(t : ('a * 'b)) : 'a = switch(t)
+    (x, _) => x
+
+  function snd(t : ('a * 'b)) : 'b = switch(t)
+    (_, y) => y
+
+  function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
+    (x, y) => (f(x), y)
+
+  function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
+    (x, y) => (x, f(y))
+
+  function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
+    (x, y) => (f(x), g(y))
+
+  function swap(t : ('a * 'b)) : ('b * 'a) = switch(t)
+    (x, y) => (y, x)
+
@@ -0,0 +1,37 @@
+namespace Triple =
+
+  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
+    (x, _, _) => x
+
+  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
+    (_, y, _) => y
+
+  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
+    (_, _, z) => z
+
+
+  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
+    (x, y, z) => (f(x), y, z)
+
+  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
+    (x, y, z) => (x, f(y), z)
+
+  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
+    (x, y, z) => (x, y, f(z))
+
+  function trimap( f : 'a => 'x
+                 , g : 'b => 'y
+                 , h : 'c => 'z
+                 , t : ('a * 'b * 'c)
+                 ) : ('x * 'y * 'z) = switch(t)
+    (x, y, z) => (f(x), g(y), h(z))
+
+  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
+    (x, y, z) => (z, y, x)
+
+  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
+    (x, y, z) => (z, x, y)
+
+  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
+    (x, y, z) => (y, z, x)
+
@@ -2,7 +2,7 @@

 {erl_opts, [debug_info]}.

-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"10cc127"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"72b2a58"}}}
       , {getopt, "1.0.1"}
       , {eblake2, "1.0.0"}
       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -1,17 +1,21 @@
 {"1.1.0",
 [{<<"aebytecode">>,
  {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"10cc1278831ad7e90138533466ceef4bcafd74a9"}},
+       {ref,"72b2a581d5a6d488a208331da88de1a488ac2da1"}},
  0},
 {<<"aeserialization">>,
  {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
+       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
  1},
 {<<"base58">>,
  {git,"https://github.com/aeternity/erl-base58.git",
       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
  2},
 {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
+ {<<"enacl">>,
+  {git,"https://github.com/aeternity/enacl.git",
+       {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
+  2},
 {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
 {<<"jsx">>,
  {git,"https://github.com/talentdeficit/jsx.git",
@@ -443,7 +443,7 @@ global_env() ->
        { funs = MkDefs(
                     [{"resolve",  Fun([String, String], option_t(Ann, A))},
                      {"preclaim", SignFun([Address, Hash], Unit)},
-                      {"claim",    SignFun([Address, String, Int], Unit)},
+                      {"claim",    SignFun([Address, String, Int, Int], Unit)},
                      {"transfer", SignFun([Address, Address, String], Unit)},
                      {"revoke",   SignFun([Address, String], Unit)}]) },

@@ -767,7 +767,9 @@ check_type(Env, Type = {fun_t, Ann, NamedArgs, Args, Ret}, Arity) ->
    {fun_t, Ann, NamedArgs1, Args1, Ret1};
 check_type(_Env, Type = {uvar, _, _}, Arity) ->
    ensure_base_type(Type, Arity),
-    Type.
+    Type;
+check_type(_Env, {args_t, Ann, Ts}, _) ->
+    type_error({new_tuple_syntax, Ann, Ts}).

 ensure_base_type(Type, Arity) ->
    [ type_error({wrong_type_arguments, Type, Arity, 0}) || Arity /= 0 ],
@@ -1325,7 +1327,7 @@ infer_block(Env, _, [E], BlockType) ->
    [check_expr(Env, E, BlockType)];
 infer_block(Env, Attrs, [Def={letfun, Ann, _, _, _, _}|Rest], BlockType) ->
    {{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
-    FunT = freshen_type(Ann, typesig_to_fun_t(TypeSig)),
+    FunT = typesig_to_fun_t(TypeSig),
    NewE = bind_var({id, Ann, Name}, FunT, Env),
    [LetFun|infer_block(NewE, Attrs, Rest, BlockType)];
 infer_block(Env, _, [{letval, Attrs, Pattern, Type, E}|Rest], BlockType) ->
@@ -1352,6 +1354,9 @@ infer_infix({RelOp, As})
    T = fresh_uvar(As),     %% allow any type here, check in ast_to_icode that we have comparison for it
    Bool = {id, As, "bool"},
    {fun_t, As, [], [T, T], Bool};
+infer_infix({'..', As}) ->
+    Int = {id, As, "int"},
+    {fun_t, As, [], [Int, Int], {app_t, As, {id, As, "list"}, [Int]}};
 infer_infix({'::', As}) ->
    ElemType = fresh_uvar(As),
    ListType = {app_t, As, {id, As, "list"}, [ElemType]},
@@ -2219,6 +2224,9 @@ pp_error({contract_has_no_entrypoints, Con}) ->
                  "'function'.\n", [pp_expr("", Con), pp_loc(Con)]);
 pp_error({unbound_type, Type}) ->
    io_lib:format("Unbound type ~s (at ~s).\n", [pp_type("", Type), pp_loc(Type)]);
+pp_error({new_tuple_syntax, Ann, Ts}) ->
+    io_lib:format("Invalid type\n~s  (at ~s)\nThe syntax of tuple types changed in Sophia version 4.0. Did you mean\n~s\n",
+                  [pp_type("  ", {args_t, Ann, Ts}), pp_loc(Ann), pp_type("  ", {tuple_t, Ann, Ts})]);
 pp_error(Err) ->
    io_lib:format("Unknown error: ~p\n", [Err]).

@@ -185,7 +185,7 @@ builtins() ->
              {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                              {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                              {"check", 1}, {"check_query", 2}]},
-              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 4}, {"transfer", 4},
+              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
                              {"revoke", 3}]},
              {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                              {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
@@ -282,10 +282,13 @@ decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, {id, _, Name}, Args, R
    Attrs = get_attributes(Ann),
    FName = lookup_fun(Env, qname(Env, Name)),
    FArgs = args_to_fcode(Env, Args),
+    FRet  = type_to_fcode(Env, Ret),
    FBody = expr_to_fcode(Env#{ vars => [X || {X, _} <- FArgs] }, Body),
+    [ ensure_first_order_entrypoint(Ann, FArgs, FRet)
+      || aeso_syntax:get_ann(entrypoint, Ann, false) ],
    Def   = #{ attrs  => Attrs,
               args   => FArgs,
-               return => type_to_fcode(Env, Ret),
+               return => FRet,
               body   => FBody },
    NewFuns = Funs#{ FName => Def },
    Env#{ functions := NewFuns }.
@@ -453,12 +456,16 @@ expr_to_fcode(Env, _Type, {list, _, Es}) ->
    lists:foldr(fun(E, L) -> {op, '::', [expr_to_fcode(Env, E), L]} end,
                nil, Es);

+expr_to_fcode(Env, _Type, {app, _, {'..', _}, [A, B]}) ->
+    {def_u, FromTo, _} = resolve_fun(Env, ["ListInternal", "from_to"]),
+    {def, FromTo, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]};
+
 expr_to_fcode(Env, _Type, {list_comp, _, Yield, []}) ->
    {op, '::', [expr_to_fcode(Env, Yield), nil]};
 expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, {typed, {id, _, Arg}, _}, BindExpr}|Rest]}) ->
    Env1 = bind_var(Env, Arg),
    Bind = {lam, [Arg], expr_to_fcode(Env1, {list_comp, As, Yield, Rest})},
-    {def_u, FlatMap, _} = resolve_fun(Env, ["List", "flat_map"]),
+    {def_u, FlatMap, _} = resolve_fun(Env, ["ListInternal", "flat_map"]),
    {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
 expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
    make_if(expr_to_fcode(Env, Cond),
@@ -506,7 +513,7 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
    end;

 %% Function calls
-expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, Type, {app, _, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
    Args1 = get_named_args(NamedArgsT, Args),
    FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
    case expr_to_fcode(Env, Fun) of
@@ -520,11 +527,13 @@ expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT,
            %% Get the type of the oracle from the args or the expression itself
            OType = get_oracle_type(B, Type, Args1),
            {oracle, QType, RType} = type_to_fcode(Env, OType),
+            validate_oracle_type(aeso_syntax:get_ann(Fun), QType, RType),
            TypeArgs = [{lit, {typerep, QType}}, {lit, {typerep, RType}}],
            builtin_to_fcode(B, FArgs ++ TypeArgs);
        {builtin_u, B, _} when B =:= aens_resolve ->
            %% Get the type we are assuming the name resolves to
            AensType = type_to_fcode(Env, Type),
+            validate_aens_resolve_type(aeso_syntax:get_ann(Fun), AensType),
            TypeArgs = [{lit, {typerep, AensType}}],
            builtin_to_fcode(B, FArgs ++ TypeArgs);
        {builtin_u, B, _Ar}       -> builtin_to_fcode(B, FArgs);
@@ -600,6 +609,46 @@ get_oracle_type(oracle_check,        _Type, [{typed, _, _Expr, OType}])       ->
 get_oracle_type(oracle_check_query,  _Type, [{typed, _, _Expr, OType} | _])   -> OType;
 get_oracle_type(oracle_respond,      _Type, [_, {typed, _,_Expr, OType} | _]) -> OType.

+validate_oracle_type(Ann, QType, RType) ->
+    ensure_monomorphic(QType, {polymorphic_query_type, Ann, QType}),
+    ensure_monomorphic(RType, {polymorphic_response_type, Ann, RType}),
+    ensure_first_order(QType, {higher_order_query_type, Ann, QType}),
+    ensure_first_order(RType, {higher_order_response_type, Ann, RType}),
+    ok.
+
+validate_aens_resolve_type(Ann, {variant, [[], [Type]]}) ->
+    ensure_monomorphic(Type, {polymorphic_aens_resolve, Ann, Type}),
+    ensure_first_order(Type, {higher_order_aens_resolve, Ann, Type}),
+    ok.
+
+ensure_first_order_entrypoint(Ann, Args, Ret) ->
+    [ ensure_first_order(T, {higher_order_entrypoint_argument, Ann, X, T})
+      || {X, T} <- Args ],
+    ensure_first_order(Ret, {higher_order_entrypoint_return, Ann, Ret}),
+    ok.
+
+ensure_monomorphic(Type, Err) ->
+    case is_monomorphic(Type) of
+        true  -> ok;
+        false -> fcode_error(Err)
+    end.
+
+ensure_first_order(Type, Err) ->
+    case is_first_order(Type) of
+        true  -> ok;
+        false -> fcode_error(Err)
+    end.
+
+is_monomorphic({tvar, _})              -> false;
+is_monomorphic(Ts) when is_list(Ts)    -> lists:all(fun is_monomorphic/1, Ts);
+is_monomorphic(Tup) when is_tuple(Tup) -> is_monomorphic(tuple_to_list(Tup));
+is_monomorphic(_)                      -> true.
+
+is_first_order({function, _, _})       -> false;
+is_first_order(Ts) when is_list(Ts)    -> lists:all(fun is_first_order/1, Ts);
+is_first_order(Tup) when is_tuple(Tup) -> is_first_order(tuple_to_list(Tup));
+is_first_order(_)                      -> true.
+
 %% -- Pattern matching --

 -spec alts_to_fcode(env(), ftype(), var_name(), [aeso_syntax:alt()]) -> fsplit().
@@ -1551,4 +1600,3 @@ pp_pat(Pat)              -> pp_fexpr(Pat).
 is_infix(Op) ->
    C = hd(atom_to_list(Op)),
    C < $a orelse C > $z.
-
@@ -93,6 +93,8 @@ contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest]
    FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
               [ payable  || proplists:get_value(payable, Attrib, false) ] ++
               [ private  || is_private(Attrib, Icode) ],
+    [ check_entrypoint_type(Attrib, Name, Args, T)
+      || aeso_syntax:get_ann(entrypoint, Attrib, false) ],
    %% TODO: Handle types
    FunName = ast_id(Name),
    %% TODO: push funname to env
@@ -105,7 +107,7 @@ contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest]
                #{ state_type := StateType } = Icode,
                {#tuple{ cpts = [type_value(StateType), ast_body(Body, Icode)] },
                 {tuple, [typerep, ast_typerep(T, Icode)]}};
-            _ -> {ast_body(Body, Icode), ast_typerep(T, Icode)}
+            _ -> {ast_body(Body, Icode), ast_typerep1(T, Icode)}
        end,
    QName    = aeso_icode:qualify(Name, Icode),
    NewIcode = ast_fun_to_icode(ast_id(QName), FunAttrs, FunArgs, FunBody, TypeRep, Icode),
@@ -121,7 +123,7 @@ ast_id({id, _, Id}) -> Id;
 ast_id({qid, _, Id}) -> Id.

 ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
-    ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
+    ast_args(Rest, [{ast_id(Name), ast_typerep1(Type, Icode)}| Acc], Icode);
 ast_args([], Acc, _Icode) -> lists:reverse(Acc).

 ast_type(T, Icode) ->
@@ -268,10 +270,10 @@ ast_body(?qid_app(["AENS", "preclaim"], Args, _, _), Icode) ->
              [word, word, sign_t()], {tuple, []});

 ast_body(?qid_app(["AENS", "claim"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name, Salt]} = get_signature_arg(Args),
+    {Sign, [Addr, Name, Salt, NameFee]} = get_signature_arg(Args),
    prim_call(?PRIM_CALL_AENS_CLAIM, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(Sign, Icode)],
-              [word, string, word, sign_t()], {tuple, []});
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(NameFee, Icode), ast_body(Sign, Icode)],
+              [word, string, word, word, sign_t()], {tuple, []});

 ast_body(?qid_app(["AENS", "transfer"], Args, _, _), Icode) ->
    {Sign, [FromAddr, ToAddr, Name]} = get_signature_arg(Args),
@@ -523,6 +525,10 @@ ast_body({app, _, {typed, _, {con, _, Name}, _}, Args}, Icode) ->
 ast_body({app, _, {typed, _, {qcon, _, Name}, _}, Args}, Icode) ->
    Tag = aeso_icode:get_constructor_tag(Name, Icode),
    #tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
+ast_body({app, _, {'..', _}, [A, B]}, Icode) ->
+    #funcall
+    { function = #var_ref{ name = ["ListInternal", "from_to"] }
+    , args     = [ast_body(A, Icode), ast_body(B, Icode)] };
 ast_body({app,As,Fun,Args}, Icode) ->
    case aeso_syntax:get_ann(format, As) of
        infix  ->
@@ -541,7 +547,7 @@ ast_body({list_comp, _, Yield, []}, Icode) ->
    #list{elems = [ast_body(Yield, Icode)]};
 ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
    #funcall
-        { function = #var_ref{ name = ["List", "flat_map"] }
+        { function = #var_ref{ name = ["ListInternal", "flat_map"] }
        , args =
              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
@@ -578,7 +584,7 @@ ast_body({block,As,[E|Rest]}, Icode) ->
    #switch{expr=ast_body(E, Icode),
            cases=[{#var_ref{name="_"},ast_body({block,As,Rest}, Icode)}]};
 ast_body({lam,_,Args,Body}, Icode) ->
-    #lambda{args=[#arg{name = ast_id(P), type = ast_type(T, Icode)} || {arg,_,P,T} <- Args],
+    #lambda{args=[#arg{name = ast_id(P), type = ast_typerep1(T, Icode)} || {arg,_,P,T} <- Args],
            body=ast_body(Body, Icode)};
 ast_body({typed,_,{record,Attrs,Fields},{record_t,DefFields}}, Icode) ->
    %% Compile as a tuple with the fields in the order they appear in the definition.
@@ -713,6 +719,22 @@ map_upd(Key, Default, ValFun, Map = {typed, Ann, _, MapType}, Icode) ->
    Args    = [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Default, Icode), ast_body(ValFun, Icode)],
    builtin_call(FunName, Args).

+check_entrypoint_type(Ann, Name, Args, Ret) ->
+    Check = fun(T, Err) ->
+                case is_simple_type(T) of
+                    false -> gen_error(Err);
+                    true  -> ok
+                end end,
+    [ Check(T, {entrypoint_argument_must_have_simple_type, Ann1, Name, X, T})
+      || {arg, Ann1, X, T} <- Args ],
+    Check(Ret, {entrypoint_must_have_simple_return_type, Ann, Name, Ret}).
+
+is_simple_type({tvar, _, _})        -> false;
+is_simple_type({fun_t, _, _, _, _}) -> false;
+is_simple_type(Ts) when is_list(Ts) -> lists:all(fun is_simple_type/1, Ts);
+is_simple_type(T) when is_tuple(T)  -> is_simple_type(tuple_to_list(T));
+is_simple_type(_)                   -> true.
+
 is_monomorphic({tvar, _, _}) -> false;
 is_monomorphic([H|T]) ->
  is_monomorphic(H) andalso is_monomorphic(T);
@@ -753,42 +775,49 @@ make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
    TVars = [ X || {tvar, _, X} <- Args ],
    fun(Types) ->
        TypeEnv1 = maps:from_list(lists:zip(TVars, Types)),
-        ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
+        ast_typerep1(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
    end.

 -spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
-ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
+ast_typerep(Type) ->
+    ast_typerep(Type, aeso_icode:new([])).

-ast_typerep({id, _, Name}, Icode) ->
+ast_typerep(Type, Icode) ->
+    case is_simple_type(Type) of
+        false -> gen_error({not_a_simple_type, Type});
+        true  -> ast_typerep1(Type, Icode)
+    end.
+
+ast_typerep1({id, _, Name}, Icode) ->
    lookup_type_id(Name, [], Icode);
-ast_typerep({qid, _, Name}, Icode) ->
+ast_typerep1({qid, _, Name}, Icode) ->
    lookup_type_id(Name, [], Icode);
-ast_typerep({con, _, _}, _) ->
+ast_typerep1({con, _, _}, _) ->
    word;   %% Contract type
-ast_typerep({bytes_t, _, Len}, _) ->
+ast_typerep1({bytes_t, _, Len}, _) ->
    bytes_t(Len);
-ast_typerep({app_t, _, {I, _, Name}, Args}, Icode) when I =:= id; I =:= qid ->
-    ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
+ast_typerep1({app_t, _, {I, _, Name}, Args}, Icode) when I =:= id; I =:= qid ->
+    ArgReps = [ ast_typerep1(Arg, Icode) || Arg <- Args ],
    lookup_type_id(Name, ArgReps, Icode);
-ast_typerep({tvar,_,A}, #{ type_vars := TypeVars }) ->
+ast_typerep1({tvar,_,A}, #{ type_vars := TypeVars }) ->
    case maps:get(A, TypeVars, undefined) of
        undefined -> word; %% We serialize type variables just as addresses in the originating VM.
        Type      -> Type
    end;
-ast_typerep({tuple_t,_,Cpts}, Icode) ->
-    {tuple, [ast_typerep(C, Icode) || C<-Cpts]};
-ast_typerep({record_t,Fields}, Icode) ->
+ast_typerep1({tuple_t,_,Cpts}, Icode) ->
+    {tuple, [ast_typerep1(C, Icode) || C<-Cpts]};
+ast_typerep1({record_t,Fields}, Icode) ->
    {tuple, [ begin
                {field_t, _, _, T} = Field,
-                ast_typerep(T, Icode)
+                ast_typerep1(T, Icode)
              end || Field <- Fields]};
-ast_typerep({fun_t,_,_,_,_}, _Icode) ->
+ast_typerep1({fun_t,_,_,_,_}, _Icode) ->
    function;
-ast_typerep({alias_t, T}, Icode) -> ast_typerep(T, Icode);
-ast_typerep({variant_t, Cons}, Icode) ->
+ast_typerep1({alias_t, T}, Icode) -> ast_typerep1(T, Icode);
+ast_typerep1({variant_t, Cons}, Icode) ->
    {variant, [ begin
                  {constr_t, _, _, Args} = Con,
-                  [ ast_typerep(Arg, Icode) || Arg <- Args ]
+                  [ ast_typerep1(Arg, Icode) || Arg <- Args ]
                end || Con <- Cons ]}.

 ttl_t(Icode) ->
@@ -837,13 +866,6 @@ type_value({map, K, V}) ->
    #tuple{ cpts = [#integer{ value = ?TYPEREP_MAP_TAG },
                    type_value(K), type_value(V)] }.

-%% As abort is a built-in in the future it will be illegal to for
-%% users to define abort. For the time being strip away all user
-%% defined abort functions.
-
-ast_fun_to_icode("abort", _Atts, _Args, _Body, _TypeRep, Icode) ->
-    %% Strip away all user defined abort functions.
-    Icode;
 ast_fun_to_icode(Name, Attrs, Args, Body, TypeRep, #{functions := Funs} = Icode) ->
    NewFuns = [{Name, Attrs, Args, Body, TypeRep}| Funs],
    aeso_icode:set_functions(NewFuns, Icode).
@@ -36,7 +36,6 @@
                | pp_assembler
                | pp_bytecode
                | no_code
-                | no_implicit_stdlib
                | {backend, aevm | fate}
                | {include, {file_system, [string()]} |
                            {explicit_files, #{string() => binary()}}}
@@ -142,16 +141,7 @@ from_string1(fate, ContractString, Options) ->

 -spec string_to_code(string(), options()) -> map().
 string_to_code(ContractString, Options) ->
-    Ast = case lists:member(no_implicit_stdlib, Options) of
-              true -> parse(ContractString, Options);
-              false ->
-                  IncludedSTD = sets:from_list(
-                                  [aeso_parser:hash_include(F, C)
-                                   || {F, C} <- aeso_stdlib:stdlib_list()]),
-                  InitAst = parse(ContractString, IncludedSTD, Options),
-                  STD = parse_stdlib(),
-                  STD ++ InitAst
-          end,
+    Ast = parse(ContractString, Options),
    pp_sophia_code(Ast, Options),
    pp_ast(Ast, Options),
    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
@@ -317,7 +307,7 @@ to_sophia_value(_, _, revert, Data, Options) ->
            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
    end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
    try
        Code = string_to_code(ContractString, Options),
        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -378,7 +368,7 @@ create_calldata(Code, Fun, Args) ->
                             {ok, binary()}
                             | {error, term()}.
 create_calldata(Code, Fun, Args, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
    case proplists:get_value(backend, Options, aevm) of
        aevm ->
            case check_call(Code, Fun, Args, Options) of
@@ -401,7 +391,7 @@ decode_calldata(ContractString, FunName, Calldata) ->
    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).

 decode_calldata(ContractString, FunName, Calldata, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
    try
        Code = string_to_code(ContractString, Options),
        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -579,15 +569,6 @@ pp(Code, Options, Option, PPFun) ->

 %% -------------------------------------------------------------------

-spec parse_stdlib() -> none() | aeso_syntax:ast().
-parse_stdlib() ->
-    lists:foldr(
-      fun ({Lib, LibCode}, Acc) ->
-              parse(LibCode, [{src_file, binary_to_list(Lib)}]) ++ Acc
-      end,
-      [],
-      aeso_stdlib:stdlib_list()).
-
 sophia_type_to_typerep(String) ->
    {ok, Ast} = aeso_parser:type(String),
    try aeso_ast_to_icode:ast_typerep(Ast) of
@@ -114,13 +114,16 @@
     Op =:= 'CREATOR'              orelse
     false)).

-record(env, { contract, vars = [], locals = [], tailpos = true }).
+-record(env, { contract, vars = [], locals = [], current_function, tailpos = true }).

 %% -- Debugging --------------------------------------------------------------

-debug(Tag, Options, Fmt, Args) ->
+is_debug(Tag, Options) ->
    Tags = proplists:get_value(debug, Options, []),
-    case Tags == all orelse lists:member(Tag, Tags) of
+    Tags == all orelse lists:member(Tag, Tags).
+
+debug(Tag, Options, Fmt, Args) ->
+    case is_debug(Tag, Options) of
        true  -> io:format(Fmt, Args);
        false -> ok
    end.
@@ -154,10 +157,10 @@ functions_to_scode(ContractName, Functions, Options) ->
                    attrs  := Attrs,
                    return := Type}} <- maps:to_list(Functions)]).

-function_to_scode(ContractName, Functions, _Name, Attrs0, Args, Body, ResType, _Options) ->
+function_to_scode(ContractName, Functions, Name, Attrs0, Args, Body, ResType, _Options) ->
    {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    SCode = to_scode(init_env(ContractName, Functions, Args), Body),
+    SCode = to_scode(init_env(ContractName, Functions, Name, Args), Body),
    {Attrs, {ArgTypes, ResType1}, SCode}.

 -define(tvars, '$tvars').
@@ -199,10 +202,11 @@ type_to_scode({tvar, X}) ->

 %% -- Environment functions --

-init_env(ContractName, FunNames, Args) ->
+init_env(ContractName, FunNames, Name, Args) ->
    #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
          contract  = ContractName,
          locals    = FunNames,
+          current_function = Name,
          tailpos   = true }.

 next_var(#env{ vars = Vars }) ->
@@ -305,6 +309,24 @@ to_scode(Env, {'let', X, Expr, Body}) ->
      aeb_fate_ops:store({var, I}, {stack, 0}),
      to_scode(Env1, Body) ];

+to_scode(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}) ->
+    %% Tail-call to current function, f(e0..en). Compile to
+    %%      [ let xi = ei ]
+    %%      [ STORE argi xi ]
+    %%      jump 0
+    {Vars, Code, _Env} =
+        lists:foldl(fun(Arg, {Is, Acc, Env1}) ->
+                        {I, Env2} = bind_local("_", Env1),
+                        ArgCode   = to_scode(notail(Env2), Arg),
+                        Acc1 = [Acc, ArgCode,
+                                aeb_fate_ops:store({var, I}, ?a)],
+                        {[I | Is], Acc1, Env2}
+                    end, {[], [], Env}, Args),
+    [ Code,
+      [ aeb_fate_ops:store({arg, I}, {var, J})
+        || {I, J} <- lists:zip(lists:seq(0, length(Vars) - 1),
+                               lists:reverse(Vars)) ],
+      loop ];
 to_scode(Env, {def, Fun, Args}) ->
    FName = make_function_id(Fun),
    Lbl   = aeb_fate_data:make_string(FName),
@@ -535,8 +557,8 @@ builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = Args) ->
 builtin_to_scode(Env, aens_preclaim, [_Sign, _Account, _Hash] = Args) ->
    call_to_scode(Env, [aeb_fate_ops:aens_preclaim(?a, ?a, ?a),
                        tuple(0)], Args);
-builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a),
+builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt, _NameFee] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a, ?a),
                        tuple(0)], Args);
 builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
    call_to_scode(Env, [aeb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
@@ -662,12 +684,15 @@ pp_ann(Ind, [{i, #{ live_in := In, live_out := Out }, I} | Code]) ->
    Fmt = fun([]) -> "()";
             (Xs) -> string:join([lists:concat(["var", N]) || {var, N} <- Xs], " ")
          end,
-    Op  = [Ind, aeb_fate_pp:format_op(I, #{})],
+    Op  = [Ind, pp_op(I)],
    Ann = [["   % ", Fmt(In), " -> ", Fmt(Out)] || In ++ Out /= []],
    [io_lib:format("~-40s~s\n", [Op, Ann]),
     pp_ann(Ind, Code)];
 pp_ann(_, []) -> [].

+pp_op(loop) -> "LOOP";
+pp_op(I)    ->
+    aeb_fate_pp:format_op(I, #{}).

 pp_arg(?i(I))    -> io_lib:format("~w", [I]);
 pp_arg({arg, N}) -> io_lib:format("arg~p", [N]);
@@ -734,6 +759,7 @@ attributes(I) ->
    Pure   = fun(W, R) -> Attr(W, R, true) end,
    Impure = fun(W, R) -> Attr(W, R, false) end,
    case I of
+        loop                                  -> Impure(pc, []);
        'RETURN'                              -> Impure(pc, []);
        {'RETURNR', A}                        -> Impure(pc, A);
        {'CALL', _}                           -> Impure(?a, []);
@@ -857,7 +883,7 @@ attributes(I) ->
        {'ORACLE_QUERY_FEE', A, B}            -> Impure(A, [B]);
        {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
        {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
-        {'AENS_CLAIM', A, B, C, D}            -> Impure(none, [A, B, C, D]);
+        {'AENS_CLAIM', A, B, C, D, E}         -> Impure(none, [A, B, C, D, E]);
        'AENS_UPDATE'                         -> Impure(none, []);%% TODO
        {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
        {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
@@ -936,15 +962,29 @@ simpl_s({switch, Arg, Type, Alts, Def}, Options) ->
    {switch, Arg, Type, [simplify(A, Options) || A <- Alts], simplify(Def, Options)};
 simpl_s(I, _) -> I.

-simpl_top(I, Code, Options) ->
-    apply_rules(rules(), I, Code, Options).
+%% Safe-guard against loops in the rewriting. Shouldn't happen so throw an
+%% error if we run out.
+-define(SIMPL_FUEL, 5000).

-apply_rules(Rules, I, Code, Options) ->
-    Cons = fun(X, Xs) -> simpl_top(X, Xs, Options) end,
+simpl_top(I, Code, Options) ->
+    simpl_top(?SIMPL_FUEL, I, Code, Options).
+
+simpl_top(0, I, Code, _Options) ->
+    error({out_of_fuel, I, Code});
+simpl_top(Fuel, I, Code, Options) ->
+    apply_rules(Fuel, rules(), I, Code, Options).
+
+apply_rules(Fuel, Rules, I, Code, Options) ->
+    Cons = fun(X, Xs) -> simpl_top(Fuel - 1, X, Xs, Options) end,
    case apply_rules_once(Rules, I, Code) of
        false -> [I | Code];
        {RName, New, Rest} ->
-            debug(opt_rules, Options, "  Applied ~p:\n~s  ==>\n~s\n", [RName, pp_ann("    ", [I | Code]), pp_ann("    ", New ++ Rest)]),
+            case is_debug(opt_rules, Options) of
+                true ->
+                    {OldCode, NewCode} = drop_common_suffix([I | Code], New ++ Rest),
+                    debug(opt_rules, Options, "  Applied ~p:\n~s  ==>\n~s\n", [RName, pp_ann("    ", OldCode), pp_ann("    ", NewCode)]);
+                false -> ok
+            end,
            lists:foldr(Cons, Rest, New)
    end.

@@ -968,6 +1008,7 @@ merge_rules() ->
 rules() ->
    merge_rules() ++
    [?RULE(r_swap_push),
+     ?RULE(r_swap_pop),
     ?RULE(r_swap_write),
     ?RULE(r_constant_propagation),
     ?RULE(r_prune_impossible_branches),
@@ -1005,11 +1046,12 @@ inline_push(Ann1, Arg, Stack, [{i, Ann2, I} = AI | Code], Acc) ->
                    {As0, As1} = split_stack_arg(Stack, As),
                    Acc1 = [{i, merge_ann(Ann1, Ann2), from_op_view(Op, R, As0 ++ [Arg] ++ As1)} | Acc],
                    {lists:reverse(Acc1), Code};
-                false ->
+                false when Arg /= R ->
                    {AI1, {i, Ann1b, _}} = swap_instrs({i, Ann1, {'STORE', ?a, Arg}}, AI),
-                    inline_push(Ann1b, Arg, Stack + Produces - Consumes, Code, [AI1 | Acc])
+                    inline_push(Ann1b, Arg, Stack + Produces - Consumes, Code, [AI1 | Acc]);
+                false -> false
            end;
-        false -> false
+        _ -> false
    end;
 inline_push(_, _, _, _, _) -> false.

@@ -1021,16 +1063,42 @@ split_stack_arg(N, [A | As], Acc) ->
            true    -> N end,
    split_stack_arg(N1, As, [A | Acc]).

-%% Move PUSH A past non-stack instructions.
-r_swap_push(Push = {i, _, {'STORE', ?a, _}}, [I | Code]) ->
-    case independent(Push, I) of
-        true ->
-            {I1, Push1} = swap_instrs(Push, I),
-            {[I1, Push1], Code};
-        false -> false
+%% Move PUSHes past non-stack instructions.
+r_swap_push(Push = {i, _, PushI}, [I | Code]) ->
+    case op_view(PushI) of
+        {_, ?a, _} ->
+            case independent(Push, I) of
+                true ->
+                    {I1, Push1} = swap_instrs(Push, I),
+                    {[I1, Push1], Code};
+                false -> false
+            end;
+        _ -> false
    end;
 r_swap_push(_, _) -> false.

+%% Move non-stack instruction past POPs.
+r_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
+    case independent(IA, JA) of
+        true ->
+            case {op_view(I), op_view(J)} of
+                {false, _} -> false;
+                {_, false} -> false;
+                {{_, IR, IAs}, {_, RJ, JAs}} ->
+                    NonStackI = not lists:member(?a, [IR | IAs]),
+                    %% RJ /= ?a to not conflict with r_swap_push
+                    PopJ      = RJ /= ?a andalso lists:member(?a, JAs),
+                    case NonStackI andalso PopJ of
+                        false -> false;
+                        true  ->
+                            {JA1, IA1} = swap_instrs(IA, JA),
+                            {[JA1, IA1], Code}
+                    end
+            end;
+        false -> false
+    end;
+r_swap_pop(_, _) -> false.
+
 %% Match up writes to variables with instructions further down.
 r_swap_write(I = {i, _, _}, [J | Code]) ->
    case {var_writes(I), independent(I, J)} of
@@ -1166,6 +1234,8 @@ r_float_switch_body(I = {i, _, _}, [switch_body | Code]) ->
 r_float_switch_body(_, _) -> false.

 %% Inline stores
+r_inline_store({i, _, {'STORE', R, R}}, Code) ->
+    {[], Code};
 r_inline_store(I = {i, _, {'STORE', R = {var, _}, A}}, Code) ->
    %% Not when A is var unless updating the annotations properly.
    Inline = case A of
@@ -1258,9 +1328,13 @@ unannotate(Code) when is_list(Code) ->
 unannotate({i, _Ann, I}) -> [I].

 %% Desugar and specialize
-desugar({'ADD', ?a, ?i(1), ?a})     -> [aeb_fate_ops:inc()];
-desugar({'SUB', ?a, ?a, ?i(1)})     -> [aeb_fate_ops:dec()];
-desugar({'STORE', ?a, A})           -> [aeb_fate_ops:push(A)];
+desugar({'ADD', ?a, ?i(1), ?a}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', A,  ?i(1), A})  -> [aeb_fate_ops:inc(A)];
+desugar({'ADD', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', A,  A,  ?i(1)}) -> [aeb_fate_ops:inc(A)];
+desugar({'SUB', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:dec()];
+desugar({'SUB', A, A, ?i(1)})   -> [aeb_fate_ops:dec(A)];
+desugar({'STORE', ?a, A})       -> [aeb_fate_ops:push(A)];
 desugar({switch, Arg, Type, Alts, Def}) ->
    [{switch, Arg, Type, [desugar(A) || A <- Alts], desugar(Def)}];
 desugar(missing) -> missing;
@@ -1460,7 +1534,8 @@ split_calls(Ref, [], Acc, Blocks) ->
 split_calls(Ref, [I | Code], Acc, Blocks) when element(1, I) == 'CALL';
                                               element(1, I) == 'CALL_R';
                                               element(1, I) == 'CALL_GR';
-                                               element(1, I) == 'jumpif' ->
+                                               element(1, I) == 'jumpif';
+                                               I == loop ->
    split_calls(make_ref(), Code, [], [{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [{'ABORT', _} = I | _Code], Acc, Blocks) ->
    lists:reverse([{Ref, lists:reverse([I | Acc])} | Blocks]);
@@ -1473,7 +1548,8 @@ split_calls(Ref, [I | Code], Acc, Blocks) ->

 set_labels(Labels, {Ref, Code}) when is_reference(Ref) ->
    {maps:get(Ref, Labels), [ set_labels(Labels, I) || I <- Code ]};
-set_labels(Labels, {jump, Ref})   -> aeb_fate_ops:jump(maps:get(Ref, Labels));
+set_labels(_Labels, loop)              -> aeb_fate_ops:jump(0);
+set_labels(Labels, {jump, Ref})        -> aeb_fate_ops:jump(maps:get(Ref, Labels));
 set_labels(Labels, {jumpif, Arg, Ref}) -> aeb_fate_ops:jumpif(Arg, maps:get(Ref, Labels));
 set_labels(Labels, {switch, Arg, Refs}) ->
    case [ maps:get(Ref, Labels) || Ref <- Refs ] of
@@ -1488,3 +1564,10 @@ set_labels(_, I) -> I.
 with_ixs(Xs) ->
    lists:zip(lists:seq(0, length(Xs) - 1), Xs).

+drop_common_suffix(Xs, Ys) ->
+    drop_common_suffix_r(lists:reverse(Xs), lists:reverse(Ys)).
+
+drop_common_suffix_r([X | Xs], [X | Ys]) ->
+    drop_common_suffix_r(Xs, Ys);
+drop_common_suffix_r(Xs, Ys) ->
+    {lists:reverse(Xs), lists:reverse(Ys)}.
@@ -78,6 +78,7 @@ builtin_types() ->
     , "string"       => fun([]) -> string end
     , "address"      => Word
     , "hash"         => Word
+     , "unit"         => fun([]) -> {tuple, []} end
     , "signature"    => fun([]) -> {tuple, [word, word]} end
     , "oracle"       => fun([_, _]) -> word end
     , "oracle_query" => fun([_, _]) -> word end
@@ -150,7 +150,7 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().

 type200() ->
-    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).

 type300() ->
    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
@@ -169,16 +169,15 @@ type400() ->
 typeAtom() ->
    ?LAZY_P(choice(
    [ parens(type())
+    , args_t()
    , id(), token(con), token(qcon), token(qid), tvar()
    ])).

-fun_domain() -> ?LAZY_P(choice(
-    [ ?RULE(tok('('), tok(')'), [])
-      %% Note avoidance of ambiguity: `(int)` can be treated as:
-      %% - literally `int`
-      %% - list of arguments with just one element – int. This approach is dropped.
-    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), [_2|_4])
-    , ?RULE(type300(), [_1])
+args_t() ->
+    ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
+      %% Singleton case handled separately
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
    ])).

 %% -- Statements -------------------------------------------------------------
@@ -501,7 +500,8 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.

 fun_t(Domains, Type) ->
-    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
+    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
+                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
                Type, Domains).

 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
@@ -549,12 +549,16 @@ bad_expr_err(Reason, E) ->
                            prettypr:nest(2, aeso_pretty:expr(E))])).

 %% -- Helper functions -------------------------------------------------------
+
 expand_includes(AST, Included, Opts) ->
-    expand_includes(AST, Included, [], Opts).
+    Ann  = [{origin, system}],
+    AST1 = [ {include, Ann, {string, Ann, File}}
+             || File <- lists:usort(auto_imports(AST)) ] ++ AST,
+    expand_includes(AST1, Included, [], Opts).

 expand_includes([], _Included, Acc, _Opts) ->
    {ok, lists:reverse(Acc)};
-expand_includes([{include, Ann, {string, SAnn, File}} | AST], Included, Acc, Opts) ->
+expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
    case get_include_code(File, Ann, Opts) of
        {ok, Code} ->
            Hashed = hash_include(File, Code),
@@ -562,12 +566,9 @@ expand_includes([{include, Ann, {string, SAnn, File}} | AST], Included, Acc, Opt
                false ->
                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
                    Included1 = sets:add_element(Hashed, Included),
-                    case string(Code, Included1, Opts1) of
+                    case parse_and_scan(file(), Code, Opts1) of
                        {ok, AST1} ->
-                            Dependencies = [ {include, Ann, {string, SAnn, Dep}}
-                                             || Dep <- aeso_stdlib:dependencies(File)
-                                           ],
-                            expand_includes(Dependencies ++ AST1 ++ AST, Included1, Acc, Opts);
+                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
                        Err = {error, _} ->
                            Err
                    end;
@@ -593,12 +594,15 @@ read_file(File, Opts) ->
            end
    end.

+stdlib_options() ->
+    [{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
+
 get_include_code(File, Ann, Opts) ->
-    case {read_file(File, Opts), maps:find(File, aeso_stdlib:stdlib())} of
+    case {read_file(File, Opts), read_file(File, stdlib_options())} of
        {{ok, _}, {ok,_ }} ->
            return_error(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
-        {_, {ok, Lib}} ->
-            {ok, Lib};
+        {_, {ok, Bin}} ->
+            {ok, binary_to_list(Bin)};
        {{ok, Bin}, _} ->
            {ok, binary_to_list(Bin)};
        {_, _} ->
@@ -610,3 +614,11 @@ hash_include(File, Code) when is_binary(File) ->
    hash_include(binary_to_list(File), Code);
 hash_include(File, Code) when is_list(File) ->
    {filename:basename(File), crypto:hash(sha256, Code)}.
+
+auto_imports({comprehension_bind, _, _}) -> [<<"ListInternal.aes">>];
+auto_imports({'..', _})                  -> [<<"ListInternal.aes">>];
+auto_imports(L) when is_list(L) ->
+    lists:flatmap(fun auto_imports/1, L);
+auto_imports(T) when is_tuple(T) ->
+    auto_imports(tuple_to_list(T));
+auto_imports(_) -> [].
@@ -243,6 +243,8 @@ type({app_t, _, Type, Args}) ->
    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
    tuple_type(Args);
+type({args_t, _, Args}) ->
+    args_type(Args);
 type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
    text(lists:concat(["bytes(", Len, ")"]));
@@ -10,425 +10,8 @@

 -module(aeso_stdlib).

-export([stdlib/0, stdlib_list/0, dependencies/1]).
+-export([stdlib_include_path/0]).

-stdlib() ->
-    maps:from_list(stdlib_list()).
+stdlib_include_path() ->
+    filename:join([code:priv_dir(aesophia), "stdlib"]).

-stdlib_list() ->
-    [ {<<"List.aes">>, std_list()}
-    , {<<"Func.aes">>, std_func()}
-    , {<<"Option.aes">>, std_option()}
-    , {<<"Pair.aes">>, std_pair()}
-    , {<<"Triple.aes">>, std_triple()}
-    ].
-
-dependencies(Q) ->
-    case Q of
-        <<"Option.aes">> ->
-            [<<"List.aes">>];
-        _ -> []
-    end.
-
-std_func() ->
-"
-namespace Func =
-
-  function id(x : 'a) : 'a = x
-
-  function const(x : 'a) : 'b => 'a = (y) => x
-
-  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
-
-  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
-
-  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
-
-  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
-
-  /* The Z combinator - replacement for local and anonymous recursion.
-   */
-  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
-    (x) => f(recur(f), x)
-
-  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
-  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
-    if(n == 0) acc
-    elif(n == 1) comp(f, acc)
-    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
-
-  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
-    (x) => (y) => f(x, y)
-  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
-    (x) => (y) => (z) => f(x, y, z)
-
-  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
-    (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
-    (x, y, z) => f(x)(y)(z)
-
-  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
-    (t) => switch(t)
-      (x, y) => f(x, y)
-  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
-    (t) => switch(t)
-      (x, y, z) => f(x, y, z)
-
-  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
-    (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
-    (x, y, z) => f((x, y, z))
-".
-
-std_list() ->"
-namespace List =
-
-  function is_empty(l : list('a)) : bool = switch(l)
-    [] => true
-    _  => false
-
-  function first(l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::_ => Some(h)
-
-  function tail(l : list('a)) : option(list('a)) = switch(l)
-    []   => None
-    _::t => Some(t)
-
-  function last(l : list('a)) : option('a) = switch(l)
-    []  => None
-    [x] => Some(x)
-    _::t => last(t)
-
-  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::t => if(p(h)) Some(h) else find(p, t)
-
-  function find_all(p : 'a => bool, l : list('a)) : list('a) = find_all_(p, l, [])
-  private function find_all_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => find_all_(p, t, if(p(h)) h::acc else acc)
-
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
-  private function find_indices_( p : 'a => bool
-                                , l : list('a)
-                                , n : int
-                                , acc : list(int)
-                                ) : list(int) = switch(l)
-    []   => reverse(acc)
-    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
-
-  function nth(n : int, l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::t => if(n == 0) Some(h) else nth(n-1, t)
-
-  /* Unsafe version of `nth` */
-  function get(n : int, l : list('a)) : 'a = switch(l)
-    [] => abort(\"Out of index get\")
-    h::t => if(n == 0) h else get(n-1, t)
-
-
-  function length(l : list('a)) : int = length_(l, 0)
-  private function length_(l : list('a), acc : int) : int = switch(l)
-    []   => acc
-    _::t => length_(t, acc + 1)
-
-
-  /* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
-  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort(\"insert_at underflow\") else replace_at_(n, e, l, [])
-  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   switch(l)
-     []   => abort(\"replace_at overflow\")
-     h::t => if (n == 0) reverse(e::acc) ++ t
-             else replace_at_(n-1, e, t, h::acc)
-
-  /* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
-  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort(\"insert_at underflow\") else insert_at_(n, e, l, [])
-  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   if (n == 0) reverse(e::acc) ++ l
-   else switch(l)
-     []   => abort(\"insert_at overflow\")
-     h::t => insert_at_(n-1, e, t, h::acc)
-
-  function insert_by(f : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
-    switch(l)
-      []        => [x]
-      (e :: l') =>
-        if(f(x, e))
-          e :: insert_by(f, x, l')
-        else
-          x :: l
-
-  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
-    []   => nil
-    h::t => cons(h, foldr(cons, nil, t))
-
-  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
-    []   => acc
-    h::t => foldl(rcons, rcons(acc, h), t)
-
-  function foreach(f : 'a => unit, l : list('a)) : unit =
-    switch(l)
-     []   => ()
-     e :: l' =>
-       f(e)
-       foreach(f, l')
-
-
-  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
-
-
-  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
-  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => map_(f, t, f(h)::acc)
-
-  function flat_map(f : 'a => list('b), l : list('a)) : list('b) = flat_map_(f, l, [])
-  private function flat_map_(f : 'a => list('b), l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => flat_map_(f, t, reverse(f(h)) ++ acc)
-
-  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
-  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => filter_(p, t, if(p(h)) h::acc else acc)
-
-  /* Take `n` first elements */
-  function take(n : int, l : list('a)) : list('a) =
-    if(n < 0) abort(\"Take negative number of elements\") else take_(n, l, [])
-  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
-    if(n == 0) reverse(acc)
-    else switch(l)
-      []   => reverse(acc)
-      h::t => take_(n-1, t, h::acc)
-
-  /* Drop `n` first elements */
-  function drop(n : int, l : list('a)) : list('a) =
-   if(n < 0) abort(\"Drop negative number of elements\")
-   elif (n == 0) l
-   else switch(l)
-      []   => []
-      h::t => drop(n-1, t)
-
-  /* Get the longest prefix of a list in which every element matches predicate `p` */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
-  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
-
-  /* Drop elements from `l` until `p` holds */
-  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => if(p(h)) drop_while(p, t) else l
-
-  /* Splits list into two lists of elements that respectively match and don't match predicate `p` */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
-  private function partition_( p : 'a => bool
-                             , l : list('a)
-                             , acc_t : list('a)
-                             , acc_f : list('a)
-                             ) : (list('a) * list('a)) = switch(l)
-    []   => (reverse(acc_t), reverse(acc_f))
-    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
-
-
-  function concats(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
-
-  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => true
-    h::t => if(p(h)) all(p, t) else false
-
-  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => false
-    h::t => if(p(h)) true else any(p, t)
-
-  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
-
-  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
-
-
-  /* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
-  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
-  private function zip_with_( f : ('a, 'b) => 'c
-                            , l1 : list('a)
-                            , l2 : list('b)
-                            , acc : list('c)
-                            ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
-    _ => reverse(acc)
-
-  /* Zips two lists into list of pairs. Drops longer tail. */
-  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
-
-  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
-  private function unzip_( l     : list('a * 'b)
-                         , acc_l : list('a)
-                         , acc_r : list('b)
-                         ) : (list('a) * list('b)) = switch(l)
-    []               => (reverse(acc_l), reverse(acc_r))
-    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
-
-
-  // TODO: Improve?
-  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => switch (partition((x) => lesser_cmp(x, h), t))
-      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
-
-
-  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
-  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    [e]  => reverse(e::acc)
-    h::t => intersperse_(delim, t, delim::h::acc)
-
-
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
-  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
-    []   => reverse(acc)
-    h::t => enumerate_(t, n + 1, (n, h)::acc)
-
-".
-
-std_option() -> "
-namespace Option =
-
-  function is_none(o : option('a)) : bool = switch(o)
-    None => true
-    Some(_) => false
-
-  function is_some(o : option('a)) : bool = switch(o)
-    None => false
-    Some(_) => true
-
-
-  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
-    None => n
-    Some(x) => s(x)
-
-  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
-
-  function force(o : option('a)) : 'a = default(abort(\"Forced None value\"), o)
-
-  function on_elem(f : 'a => unit, o : option('a)) : unit = match((), f, o)
-
-
-  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => Some(f(x))
-
-  function map2(f : ('a, 'b) => 'c
-               , o1 : option('a)
-               , o2 : option('b)
-               ) : option('c) = switch((o1, o2))
-    (Some(x1), Some(x2)) => Some(f(x1, x2))
-    _ => None
-
-  function map3( f : ('a, 'b, 'c) => 'd
-               , o1 : option('a)
-               , o2 : option('b)
-               , o3 : option('c)
-               ) : option('d) = switch((o1, o2, o3))
-    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
-    _ => None
-
-  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
-    (Some(ff), Some(xx)) => Some(ff(xx))
-    _ => None
-
-  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => f(x)
-
-
-  function to_list(o : option('a)) : list('a) = switch(o)
-    None => []
-    Some(x) => [x]
-
-  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
-  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
-    []         => List.reverse(acc)
-    None::t    => filter_options_(t, acc)
-    Some(x)::t => filter_options_(t, x::acc)
-
-  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
-  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
-    []         => Some(List.reverse(acc))
-    None::t    => None
-    Some(x)::t => seq_options_(t, x::acc)
-
-
-  function choose(o1 : option('a), o2 : option('a)) : option('a) =
-    if(is_some(o1)) o1 else o2
-
-  function choose_first(l : list(option('a))) : option('a) = switch(l)
-    [] => None
-    None::t    => choose_first(t)
-    Some(x)::_ => Some(x)
-".
-
-std_pair() -> "
-namespace Pair =
-
-  function fst(t : ('a * 'b)) : 'a = switch(t)
-    (x, _) => x
-
-  function snd(t : ('a * 'b)) : 'b = switch(t)
-    (_, y) => y
-
-
-  function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
-    (x, y) => (f(x), y)
-
-  function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
-    (x, y) => (x, f(y))
-
-  function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
-    (x, y) => (f(x), g(y))
-
-
-  function swap(t : ('a * 'b)) : ('b * 'a) = switch(t)
-    (x, y) => (y, x)
-".
-
-std_triple() -> "
-namespace Triple =
-
-  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
-    (x, _, _) => x
-
-  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
-    (_, y, _) => y
-
-  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
-    (_, _, z) => z
-
-
-  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
-    (x, y, z) => (f(x), y, z)
-
-  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
-    (x, y, z) => (x, f(y), z)
-
-  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
-    (x, y, z) => (x, y, f(z))
-
-  function trimap( f : 'a => 'x
-                 , g : 'b => 'y
-                 , h : 'c => 'z
-                 , t : ('a * 'b * 'c)
-                 ) : ('x * 'y * 'z) = switch(t)
-    (x, y, z) => (f(x), g(y), h(z))
-
-
-  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
-    (x, y, z) => (z, y, x)
-
-  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
-    (x, y, z) => (z, x, y)
-
-  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
-    (x, y, z) => (y, z, x)
-".
@@ -59,6 +59,7 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
              | {app_t, ann(), type(), [type()]}
              | {tuple_t, ann(), [type()]}
+              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
              | {bytes_t, ann(), integer() | any}
              | id()  | qid()
              | con() | qcon()  %% contracts
@@ -105,9 +106,9 @@
     | id() | qid() | con() | qcon()
     | constant().

-type comprehension_exp() :: [{ comprehension_bind, ann(), id(), expr()}
-                             | {comprehension_if, expr()}
-                             | letbind()].
+-type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
+                             | {comprehension_if, ann(), expr()}
+                             | letbind() ].

 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.

@@ -49,7 +49,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {type_def, _, I, _, D}   -> Plus(BindType(I), Decl(D));
            {fun_decl, _, _, T}      -> Type(T);
            {letval, _, F, T, E}     -> Sum([BindExpr(F), Type(T), Expr(E)]);
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Scoped(BindExpr(Xs), Expr(E))]);
+            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
            %% typedef()
            {alias_t, T}    -> Type(T);
            {record_t, Fs}  -> Type(Fs);
@@ -74,7 +74,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {list_comp, _, Y, []}  -> Expr(Y);
            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [{comprehension_if, E}|R]} ->
+            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
                Plus(Expr(E), Expr({list_comp, A, Y, R}));
            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
@@ -92,7 +92,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {field, _, LV, E}    -> Expr([LV, E]);
            {field, _, LV, _, E} -> Expr([LV, E]);
            %% arg()
-            {arg, _, X, T} -> Plus(Expr(X), Type(T));
+            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
            %% alt()
            {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
            %% elim()
@@ -124,12 +124,12 @@ used_types([Top] = _CurrentNS, T) ->
 entity_alg() ->
    IsBound = fun({K, _}) -> lists:member(K, [bound_term, bound_type]) end,
    Unbind  = fun(bound_term) -> term; (bound_type) -> type end,
-    Remove  = fun(Keys, Map) -> lists:foldl(fun maps:remove/2, Map, Keys) end,
+    Remove  = fun(Keys, Map) -> maps:without(Keys, Map) end,
    Scoped = fun(Xs, Ys) ->
-                Bound  = [E || E <- maps:keys(Ys), IsBound(E)],
-                Others = Remove(Bound, Ys),
+                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
                Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
-                maps:merge(Remove(Bound1, Xs), Others)
+                Others = Remove(Bound1, Ys),
+                maps:merge(Remove(Bound, Xs), Others)
            end,
    #alg{ zero   = #{}
        , plus   = fun maps:merge/2
@@ -80,11 +80,11 @@ encode_decode_sophia_string(SophiaType, String) ->
           , "  record r = {x : an_alias(int), y : variant}\n"
           , "  datatype variant = Red | Blue(map(string, int))\n"
           , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_implicit_stdlib]) of
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
        {ok, _, {[Type], _}, [Arg]} ->
            io:format("Type ~p~n", [Type]),
            Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_implicit_stdlib]) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, []) of
                {ok, Sophia} ->
                    lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                {error, Err} ->
@@ -152,7 +152,7 @@ oracle_test() ->
        "    Oracle.get_question(o, q)\n",
    {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
        aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_implicit_stdlib]),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),

    ok.

@@ -162,7 +162,7 @@ permissive_literals_fail_test() ->
        "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
        "    Chain.spend(o, 1000000)\n",
        {error, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], [no_implicit_stdlib]),
+            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
    ok.

 encode_decode_calldata(FunName, Types, Args) ->
@@ -173,8 +173,8 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
    encode_decode_calldata_(Code, FunName, Args, RetType).

 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, [no_implicit_stdlib]),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_implicit_stdlib]),
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}]),
    ?assertEqual(RetType, RetVMType),
    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
@@ -182,7 +182,7 @@ encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
        "init" ->
            ok;
        _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, [no_implicit_stdlib]),
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, []),
            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
            ?assertMatch({X, X}, {Args, Values})
    end,
@@ -9,7 +9,7 @@ simple_aci_test_() ->

 test_contract(N) ->
    {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:contract_interface(json, Contract, [no_implicit_stdlib]),
+    {ok,JSON} = aeso_aci:contract_interface(json, Contract),
    ?assertEqual([MapACI], JSON),
    ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).

@@ -90,8 +90,7 @@ aci_test_() ->
      fun() -> aci_test_contract(ContractName) end}
     || ContractName <- all_contracts()].

-all_contracts() -> [C || C <- aeso_compiler_tests:compilable_contracts()
-                             , not aeso_compiler_tests:wants_stdlib(C)].
+all_contracts() -> aeso_compiler_tests:compilable_contracts().

 aci_test_contract(Name) ->
    String = aeso_test_utils:read_contract(Name),
@@ -21,14 +21,12 @@ calldata_test_() ->
           ContractString = aeso_test_utils:read_contract(ContractName),
           AevmExprs =
              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]);
                  false -> undefined
              end,
           FateExprs =
              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
                  false -> undefined
              end,
           case FateExprs == undefined orelse AevmExprs == undefined of
@@ -47,14 +45,12 @@ calldata_aci_test_() ->
           io:format("ACI:\n~s\n", [ContractACIBin]),
           AevmExprs =
              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
                  false -> undefined
              end,
           FateExprs =
              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
                  false -> undefined
              end,
           case FateExprs == undefined orelse AevmExprs == undefined of
@@ -76,8 +76,7 @@ check_errors(Expect, ErrorString) ->

 compile(Backend, Name) ->
    compile(Backend, Name,
-            [{include, {file_system, [aeso_test_utils:contract_path()]}}]
-            ++ [no_implicit_stdlib || not wants_stdlib(Name)]).
+            [{include, {file_system, [aeso_test_utils:contract_path()]}}]).

 compile(Backend, Name, Options) ->
    String = aeso_test_utils:read_contract(Name),
@@ -375,12 +374,3 @@ failing_contracts() ->
      ]}
    ].

-wants_stdlib(Name) ->
-    lists:member
-      (Name,
-       [ "stdlib_include",
-         "list_comp",
-         "list_comp_not_a_list",
-         "list_comp_if_not_bool",
-         "list_comp_bad_shadow"
-       ]).
@@ -15,7 +15,7 @@ simple_contracts_test_() ->
            ?assertMatch(
                [{contract, _, {con, _, "Identity"},
                    [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
-                        {id, _, "x"}}]}], parse_string(Text, [no_implicit_stdlib])),
+                        {id, _, "x"}}]}], parse_string(Text)),
            ok
       end},
      {"Operator precedence test.",
@@ -81,17 +81,21 @@ parse_string(Text, Opts) ->

 parse_expr(Text) ->
    [{letval, _, _, _, Expr}] =
-        parse_string("let _ = " ++ Text, [no_implicit_stdlib]),
+        parse_string("let _ = " ++ Text),
    Expr.

 round_trip(Text) ->
-    Contract  = parse_string(Text, [no_implicit_stdlib]),
-    Text1     = prettypr:format(aeso_pretty:decls(Contract)),
-    Contract1 = parse_string(Text1, [no_implicit_stdlib]),
+    Contract  = parse_string(Text),
+    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
+    Contract1 = parse_string(Text1),
    NoSrcLoc  = remove_line_numbers(Contract),
    NoSrcLoc1 = remove_line_numbers(Contract1),
    ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).

+strip_stdlib([{namespace, _, {con, _, "ListInternal"}, _} | Decls]) ->
+    strip_stdlib(Decls);
+strip_stdlib(Decls) -> Decls.
+
 remove_line_numbers({line, _L}) -> {line, 0};
 remove_line_numbers({col,  _C}) -> {col, 0};
 remove_line_numbers([H|T]) ->
@@ -22,14 +22,16 @@ contract AENSTest =

  stateful entrypoint claim(addr : address,
                          name : string,
-                          salt : int) : unit =
-    AENS.claim(addr, name, salt)
+                          salt : int,
+                          name_fee : int) : unit =
+    AENS.claim(addr, name, salt, name_fee)

  stateful entrypoint signedClaim(addr : address,
                                name : string,
                                salt : int,
+                                name_fee : int,
                                sign : signature) : unit =
-    AENS.claim(addr, name, salt, signature = sign)
+    AENS.claim(addr, name, salt, name_fee, signature = sign)

  // TODO: update() -- how to handle pointers?

@@ -52,4 +54,3 @@ contract AENSTest =
                                   name      : string,
                                   sign      : signature) : unit =
    AENS.revoke(owner, name, signature = sign)
-
@@ -50,7 +50,7 @@ contract ComplexTypes =
  entrypoint remote_pair(n : int, s : string) : int * string =
    state.worker.pair(gas = 10000, n, s)

-  entrypoint map(f, xs) =
+  function map(f, xs) =
    switch(xs)
      []      => []
      x :: xs => f(x) :: map(f, xs)
@@ -10,11 +10,11 @@ contract ListComp =
    entrypoint l2_true() = [5,6,6,7,7,8]

    entrypoint l3() = [x ++ y | x <- [[":)"] | x <- [1,2]]
-                              , y <- [[":("]]]  
+                              , y <- [[":("]]]
    entrypoint l3_true() = [[":)", ":("], [":)", ":("]]

    entrypoint l4() = [(a, b, c) | let is_pit(a, b, c) = a*a + b*b == c*c
-                                 , let base = [1,2,3,4,5,6,7,8,9,10]
+                                 , let base = [1..10]
                                 , a <- base
                                 , b <- base, if (b >= a)
                                 , c <- base, if (c >= b)
@@ -0,0 +1,7 @@
+
+contract Fail =
+
+  entrypoint tttt() : bool * int =
+    let f(x : 'a) : 'a = x
+    (f(true), f(1))
+
@@ -1,5 +1,4 @@
-// This contract should be compiled with no_implicit_stdlib option.
-// It should include Lists.aes implicitly however, because Option.aes depends on it.
+// This should include Lists.aes implicitly, since Option.aes does.
 include "Option.aes"

 contract Test =
@@ -1,3 +1,6 @@
+include "List.aes"
+include "Func.aes"
+
 contract StdInc =
  entrypoint test() = List.map((x) => Func.id(x), [1,2,3,4])

@@ -91,10 +91,11 @@ contract Identity =
  // }
  // let id(x) = x
  // let main(xs) = map(double,xs)
-  entrypoint z(f,x) = x
+  function z(f,x) = x
  function s(n) = (f,x)=>f(n(f,x))
  function add(m,n) = (f,x)=>m(f,n(f,x))
-  entrypoint main(_) =
+
+  entrypoint main() =
    let three=s(s(s(z)))
    add(three,three)
       (((i)=>i+1),0)
@@ -1,6 +1,6 @@
 contract TuplesMatch =

-  entrypoint tuplify3() = (t) => switch(t)
+  function tuplify3() = (t) => switch(t)
    (x, y, z) => 3

  entrypoint fst(p : int * string) =
Author	SHA1	Message	Date
Radosław Rowicki	d14a0025f2	Merge branch 'master' into radrow-patch-2	2019-09-02 12:09:53 +02:00
Radosław Rowicki	fe0c22851f	Update CHANGELOG.md	2019-09-02 12:08:01 +02:00
Thomas Arts	a50730155f	Merge pull request #138 from aeternity/aens-at-full-node-ver-ta Compile name fee in contracts	2019-09-02 11:07:59 +02:00
Thomas Arts	e9f717a17b	Update src/aeso_ast_to_icode.erl Co-Authored-By: Ulf Norell <ulf.norell@gmail.com>	2019-09-02 10:21:35 +02:00
Ulf Norell	97ff1aac23	Merge pull request #136 from radrow/stdlib-extensions Updated some functions, renamed some stuff, added from_to IN STDLIB	2019-09-02 09:56:56 +02:00
sennui	1ee5a57924	change aebytecode version, aeserialization and add enacl	2019-09-02 08:54:38 +02:00
Thomas Arts	cf91a27fb2	Keep sign last	2019-09-01 10:58:49 +02:00
sennui	83d06977f9	add extra argument to claim for bidding	2019-09-01 10:58:49 +02:00
Ulf Norell	41e59506ba	Merge pull request #137 from aeternity/polymorpism-checks Polymorphism checks	2019-08-30 15:48:34 +02:00
Ulf Norell	062309e578	Type variables mentioned in local functions should not be flexible (cc #112)	2019-08-30 14:22:31 +02:00
Radosław Rowicki	6408969cd3	Remove from_to_	2019-08-30 14:06:46 +02:00
Radosław Rowicki	71a556ce81	nth update	2019-08-30 13:46:02 +02:00
Radosław Rowicki	256aadd575	[......] Co-Authored-By: Ulf Norell <ulf.norell@gmail.com>	2019-08-30 13:44:26 +02:00
Ulf Norell	f27ba528d8	aebytecode commit	2019-08-30 11:21:26 +02:00
Ulf Norell	6fd39d4cb1	Add checks for polymorphic/higher order oracles and higher order entrypoints (AEVM)	2019-08-30 11:18:20 +02:00
Ulf Norell	1ce95b32ac	Add checks for polymorphic/higher order oracles and higher order entrypoints (FATE)	2019-08-30 11:18:20 +02:00
radrow	076d635dbe	Fix errors	2019-08-29 15:32:10 +02:00
Radosław Rowicki	6d87960147	Merge pull request #135 from aeternity/radrow-patch-3 Remove find_all from stdlib	2019-08-29 15:25:22 +02:00
radrow	1d962f2001	Updated some functions, renamed, added from_to	2019-08-29 13:41:04 +02:00
Radosław Rowicki	cce243e513	Remove find_all from stdlib It was just a duplicated `filter`	2019-08-28 14:17:30 +02:00
Ulf Norell	60528e9128	Merge pull request #134 from aeternity/unit-to-typerep Add missing case for builtin unit type	2019-08-28 10:19:10 +02:00
Ulf Norell	80075a9d36	Add missing case for builtin unit type	2019-08-28 09:45:25 +02:00
Ulf Norell	d26fcace41	Merge pull request #133 from aeternity/stdlib-overhaul Stdlib overhaul	2019-08-28 08:38:40 +02:00
Ulf Norell	c51531f620	please dialyzer	2019-08-27 18:04:32 +02:00
Ulf Norell	3b2daf8cd6	Better errors when using old tuple type syntax	2019-08-27 15:08:56 +02:00
Ulf Norell	3ff93c5c89	Fix bug in include chasing ... making it possible for the same file to be included multiple times	2019-08-27 14:29:24 +02:00
Ulf Norell	850221aaf3	Remove no_implicit_stdlib option	2019-08-27 14:10:40 +02:00
Ulf Norell	3f1c23ace3	Use .. in list comprehension test	2019-08-27 14:00:23 +02:00
Ulf Norell	0efbcf302c	Fix roundtrip test to ignore ListInternal	2019-08-27 14:00:02 +02:00
Ulf Norell	7705138ab2	auto-import ListInternal when using list comprehensions or [a..b]	2019-08-27 13:59:36 +02:00
Ulf Norell	5f733e01dd	Implement [a..b]	2019-08-27 13:59:01 +02:00
Ulf Norell	79a928e530	Fix bad type specs	2019-08-27 13:56:02 +02:00
Ulf Norell	d23208c191	Fix bugs in dependency analysis	2019-08-27 13:55:45 +02:00
Ulf Norell	e7d3a5b9f2	Put flat_map in ListInternal.aes	2019-08-27 11:33:43 +02:00
Ulf Norell	02af75aa34	Move stdlib code to priv dir and don't do any implicit includes	2019-08-27 11:33:29 +02:00
Ulf Norell	9eed18f812	Merge pull request #132 from aeternity/fate-compiler-optimizations Fate compiler optimizations	2019-08-26 08:25:40 +02:00
Ulf Norell	07cf162703	Fix performance problem in FATE optimiser caused by debug printing	2019-08-23 10:07:43 +02:00
Ulf Norell	20064b72fa	Compile tail-calls to current function to jumps	2019-08-22 14:50:15 +02:00
Ulf Norell	a942561907	Improved optimizations of FATE code	2019-08-22 14:49:48 +02:00
Radosław Rowicki	1fbfe418c7	Update CHANGELOG.md	2019-08-22 14:23:15 +02:00