---

yaml
---
r: 2375
b: refs/heads/master
c: e3a68e2
h: refs/heads/master
i:
  2373: 7bdd3e2
  2371: 38b82c1
  2367: b5b6cdc
v: v3

Author: catamorphism

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: d9c9982f0aeb9e6e176007ef5c0490dd18834814
+refs/heads/master: e3a68e235cd077c35654f79013ad54da46d72fee

trunk/src/comp/front/ast.rs

@@ -346,7 +346,13 @@ type constr = spanned[constr_];
 
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 type fn_decl = rec(vec[arg] inputs,
-                   @ty output);
+                   @ty output,
+                   purity purity);
+tag purity {
+    pure_fn;   // declared with "pred"
+    impure_fn; // declared with "fn"
+}
+
 type _fn = rec(fn_decl decl,
                proto proto,
                block body);

trunk/src/comp/front/lexer.rs

@@ -141,6 +141,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
     keywords.insert("auto", token.AUTO);
 
     keywords.insert("fn", token.FN);
+    keywords.insert("pred", token.PRED);
     keywords.insert("iter", token.ITER);
 
     keywords.insert("import", token.IMPORT);

trunk/src/comp/front/parser.rs

@@ -242,6 +242,7 @@ fn parse_proto(parser p) -> ast.proto {
     alt (p.peek()) {
         case (token.ITER) { p.bump(); ret ast.proto_iter; }
         case (token.FN) { p.bump(); ret ast.proto_fn; }
+        case (token.PRED) { p.bump(); ret ast.proto_fn; }
         case (?t) { unexpected(p, t); }
     }
     fail;
@@ -1767,7 +1768,7 @@ fn parse_ty_params(parser p) -> vec[ast.ty_param] {
     ret ty_params;
 }
 
-fn parse_fn_decl(parser p) -> ast.fn_decl {
+fn parse_fn_decl(parser p, ast.purity purity) -> ast.fn_decl {
     auto pf = parse_arg;
     let util.common.spanned[vec[ast.arg]] inputs =
         // FIXME: passing parse_arg as an lval doesn't work at the
@@ -1790,11 +1791,12 @@ fn parse_fn_decl(parser p) -> ast.fn_decl {
     } else {
         output = @spanned(inputs.span.lo, inputs.span.hi, ast.ty_nil);
     }
-    ret rec(inputs=inputs.node, output=output);
+    // FIXME
+    ret rec(inputs=inputs.node, output=output, purity=purity);
 }
 
-fn parse_fn(parser p, ast.proto proto) -> ast._fn {
-    auto decl = parse_fn_decl(p);
+fn parse_fn(parser p, ast.proto proto, ast.purity purity) -> ast._fn {
+    auto decl = parse_fn_decl(p, purity);
     auto body = parse_block(p);
     ret rec(decl = decl,
             proto = proto,
@@ -1808,11 +1810,11 @@ fn parse_fn_header(parser p)
     ret tup(id, ty_params);
 }
 
-fn parse_item_fn_or_iter(parser p) -> @ast.item {
+fn parse_item_fn_or_iter(parser p, ast.purity purity) -> @ast.item {
     auto lo = p.get_lo_pos();
     auto proto = parse_proto(p);
     auto t = parse_fn_header(p);
-    auto f = parse_fn(p, proto);
+    auto f = parse_fn(p, proto, purity);
     auto item = ast.item_fn(t._0, f, t._1,
                             p.next_def_id(), ast.ann_none);
     ret @spanned(lo, f.body.span.hi, item);
@@ -1830,7 +1832,7 @@ fn parse_method(parser p) -> @ast.method {
     auto lo = p.get_lo_pos();
     auto proto = parse_proto(p);
     auto ident = parse_ident(p);
-    auto f = parse_fn(p, proto);
+    auto f = parse_fn(p, proto, ast.impure_fn);
     auto meth = rec(ident=ident, meth=f,
                     id=p.next_def_id(), ann=ast.ann_none);
     ret @spanned(lo, f.body.span.hi, meth);
@@ -1843,7 +1845,8 @@ fn parse_dtor(parser p) -> @ast.method {
     let vec[ast.arg] inputs = vec();
     let @ast.ty output = @spanned(lo, lo, ast.ty_nil);
     let ast.fn_decl d = rec(inputs=inputs,
-                            output=output);
+                            output=output,
+                            purity=ast.impure_fn);
     let ast._fn f = rec(decl = d,
                         proto = ast.proto_fn,
                         body = b);
@@ -1946,7 +1949,7 @@ fn parse_item_native_fn(parser p) -> @ast.native_item {
     auto lo = p.get_lo_pos();
     expect(p, token.FN);
     auto t = parse_fn_header(p);
-    auto decl = parse_fn_decl(p);
+    auto decl = parse_fn_decl(p, ast.impure_fn);
     auto link_name = none[str];
     if (p.peek() == token.EQ) {
         p.bump();
@@ -2155,6 +2158,7 @@ fn peeking_at_item(parser p) -> bool {
         case (token.GC) { ret true; }
         case (token.CONST) { ret true; }
         case (token.FN) { ret true; }
+        case (token.PRED) { ret true; }
         case (token.ITER) { ret true; }
         case (token.MOD) { ret true; }
         case (token.TYPE) { ret true; }
@@ -2176,11 +2180,17 @@ fn parse_item(parser p) -> @ast.item {
 
         case (token.FN) {
             assert (lyr == ast.layer_value);
-            ret parse_item_fn_or_iter(p);
+            ret parse_item_fn_or_iter(p, ast.impure_fn);
         }
+
+        case (token.PRED) {
+            assert (lyr == ast.layer_value);
+            ret parse_item_fn_or_iter(p, ast.pure_fn);
+        }
+
         case (token.ITER) {
             assert (lyr == ast.layer_value);
-            ret parse_item_fn_or_iter(p);
+            ret parse_item_fn_or_iter(p, ast.impure_fn);
         }
         case (token.MOD) {
             assert (lyr == ast.layer_value);

trunk/src/comp/front/token.rs

@@ -156,6 +156,7 @@ tag token {
 
     /* Callable type constructors */
     FN;
+    PRED;
     ITER;
 
     /* Object type and related keywords */
@@ -340,6 +341,7 @@ fn to_str(token t) -> str {
 
         /* Callable type constructors */
         case (FN) { ret "fn"; }
+        case (PRED) { ret "pred"; }
         case (ITER) { ret "iter"; }
 
         /* Object type */

trunk/src/comp/middle/fold.rs

@@ -30,6 +30,7 @@ import front.ast.def;
 import front.ast.def_id;
 import front.ast.ann;
 import front.ast.mt;
+import front.ast.purity;
 
 import std._uint;
 import std._vec;
@@ -301,7 +302,8 @@ type ast_fold[ENV] =
 
      (fn(&ENV e,
          vec[arg] inputs,
-         @ty output) -> ast.fn_decl)              fold_fn_decl,
+         @ty output,
+         purity p) -> ast.fn_decl)                fold_fn_decl,
 
      (fn(&ENV e, &ast._mod m) -> ast._mod)        fold_mod,
 
@@ -900,7 +902,7 @@ fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld,
         inputs += vec(fold_arg(env, fld, a));
     }
     auto output = fold_ty[ENV](env, fld, decl.output);
-    ret fld.fold_fn_decl(env, inputs, output);
+    ret fld.fold_fn_decl(env, inputs, output, decl.purity);
 }
 
 fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
@@ -1542,8 +1544,9 @@ fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block {
 
 fn identity_fold_fn_decl[ENV](&ENV e,
                               vec[arg] inputs,
-                              @ty output) -> ast.fn_decl {
-    ret rec(inputs=inputs, output=output);
+                              @ty output,
+                              purity p) -> ast.fn_decl {
+    ret rec(inputs=inputs, output=output, purity=p);
 }
 
 fn identity_fold_fn[ENV](&ENV e,
@@ -1732,7 +1735,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
          fold_ann = bind identity_fold_ann[ENV](_,_),
 
          fold_fn = bind identity_fold_fn[ENV](_,_,_,_),
-         fold_fn_decl = bind identity_fold_fn_decl[ENV](_,_,_),
+         fold_fn_decl = bind identity_fold_fn_decl[ENV](_,_,_,_),
          fold_mod = bind identity_fold_mod[ENV](_,_),
          fold_native_mod = bind identity_fold_native_mod[ENV](_,_),
          fold_crate = bind identity_fold_crate[ENV](_,_,_,_),