lib: optimize lazy functions with unchecked accesses.

* lib.h (us_lcons_fun): New inline function.
(us_cons_bind): New macro.

* eval.c (lazy_mapcar_func, lazy_mapcarv_func,  range_func,
range_star_func, generate_func, giterate_func, ginterate_func,
expand_right_fun, repeat_infinite_func, repeat_times_func,
pad_func): Use us_cons_bind, us_car, us_cdr, us_rplaca,
us_rplacd and us_lazy_cons_func, which skip the type check.

* lib.c (lazy_conses_func, lazy_appendv_func, rem_lazy_func,
lazy_flatten_func, lazy_flatcar_fund, tuples_func,
partition_by_func, partition_func, split_func,
split_star_func, partition_star_func, lazy_interpose_fun,
take_list_fun, take_while_list_fun, take_until_list_fun,
lazy_where_has_func): Likewise.

3 files changed, 156 insertions, 150 deletions

diff --git a/eval.c b/eval.c
index b628257d..89e3d18c 100644
--- a/eval.c
+++ b/eval.c
@@ -5218,15 +5218,15 @@ static val mappendv(val fun, struct args *lists)
 
 static val lazy_mapcar_func(val env, val lcons)
 {
-  cons_bind (fun, list, env);
+  us_cons_bind (fun, list, env);
 
-  rplaca(lcons, funcall1(fun, car(list)));
-  rplacd(env, cdr(list));
+  us_rplaca(lcons, funcall1(fun, car(list)));
+  us_rplacd(env, cdr(list));
 
   if (cdr(list))
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
   else
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
   return nil;
 }
 
@@ -5240,17 +5240,17 @@ val lazy_mapcar(val fun, val list)
 
 static val lazy_mapcarv_func(val env, val lcons)
 {
-  cons_bind (fun, lofl, env);
+  us_cons_bind (fun, lofl, env);
   val args = mapcar(car_f, lofl);
   val next = mapcar(cdr_f, lofl);
 
-  rplaca(lcons, apply(fun, z(args)));
-  rplacd(env, next);
+  us_rplaca(lcons, apply(fun, z(args)));
+  us_rplacd(env, next);
 
   if (all_satisfy(next, identity_f, identity_f))
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
   else
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
   return nil;
 }
 
@@ -5459,25 +5459,25 @@ static val mmakunbound(val sym)
 
 static val range_func(val env, val lcons)
 {
-  cons_bind (from, to_step, env);
-  cons_bind (to, step, to_step);
+  us_cons_bind (from, to_step, env);
+  us_cons_bind (to, step, to_step);
   val next = if3(functionp(step),
                  funcall1(step, from),
                  plus(from, step));
 
-  rplaca(lcons, from);
+  us_rplaca(lcons, from);
 
   if (to &&
       (numeq(from, to) ||
        ((lt(from, to) && gt(next, to)) ||
         (gt(from, to) && lt(next, to)))))
   {
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
     return nil;
   }
 
-  rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
-  rplaca(env, next);
+  us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
+  us_rplaca(env, next);
   return nil;
 }
 
@@ -5493,13 +5493,13 @@ static val range(val from_in, val to_in, val step_in)
 
 static val range_star_func(val env, val lcons)
 {
-  cons_bind (from, to_step, env);
-  cons_bind (to, step, to_step);
+  us_cons_bind (from, to_step, env);
+  us_cons_bind (to, step, to_step);
   val next = if3(functionp(step),
                  funcall1(step, from),
                  plus(from, step));
 
-  rplaca(lcons, from);
+  us_rplaca(lcons, from);
 
   if (to &&
       (numeq(next, to) ||
@@ -5510,8 +5510,8 @@ static val range_star_func(val env, val lcons)
     return nil;
   }
 
-  rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
-  rplaca(env, next);
+  us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
+  us_rplaca(env, next);
   return nil;
 }
 
@@ -5570,15 +5570,15 @@ static val rlist_star(struct args *items)
 
 static val generate_func(val env, val lcons)
 {
-  cons_bind (while_pred, gen_fun, env);
+  us_cons_bind (while_pred, gen_fun, env);
 
   if (!funcall(while_pred)) {
     rplacd(lcons, nil);
   } else {
     val next_item = funcall(gen_fun);
-    val lcons_next = make_lazy_cons(lcons_fun(lcons));
-    rplacd(lcons, lcons_next);
-    rplaca(lcons_next, next_item);
+    val lcons_next = make_lazy_cons(us_lcons_fun(lcons));
+    us_rplacd(lcons, lcons_next);
+    us_rplaca(lcons_next, next_item);
   }
   return nil;
 }
@@ -5597,13 +5597,13 @@ val generate(val while_pred, val gen_fun)
 
 static val giterate_func(val env, val lcons)
 {
-  cons_bind (while_pred, gen_fun, env);
-  val next_item = funcall1(gen_fun, lcons->lc.car);
+  us_cons_bind (while_pred, gen_fun, env);
+  val next_item = funcall1(gen_fun, us_car(lcons));
 
   if (funcall1(while_pred, next_item)) {
-    val lcons_next = make_lazy_cons(lcons_fun(lcons));
-    rplacd(lcons, lcons_next);
-    rplaca(lcons_next, next_item);
+    val lcons_next = make_lazy_cons(us_lcons_fun(lcons));
+    us_rplacd(lcons, lcons_next);
+    us_rplaca(lcons_next, next_item);
   }
   return nil;
 }
@@ -5616,22 +5616,22 @@ static val giterate(val while_pred, val gen_fun, val init_val)
     return nil;
   } else {
     val lc = make_lazy_cons(func_f1(cons(while_pred, gen_fun), giterate_func));
-    rplaca(lc, init_val);
+    us_rplaca(lc, init_val);
     return lc;
   }
 }
 
 static val ginterate_func(val env, val lcons)
 {
-  cons_bind (while_pred, gen_fun, env);
-  val next_item = funcall1(gen_fun, lcons->lc.car);
+  us_cons_bind (while_pred, gen_fun, env);
+  val next_item = funcall1(gen_fun, us_car(lcons));
 
   if (funcall1(while_pred, next_item)) {
-    val lcons_next = make_lazy_cons(lcons_fun(lcons));
-    rplacd(lcons, lcons_next);
-    rplaca(lcons_next, next_item);
+    val lcons_next = make_lazy_cons(us_lcons_fun(lcons));
+    us_rplacd(lcons, lcons_next);
+    us_rplaca(lcons_next, next_item);
   } else {
-    rplacd(lcons, cons(next_item, nil));
+    us_rplacd(lcons, cons(next_item, nil));
   }
   return nil;
 }
@@ -5652,18 +5652,18 @@ static val ginterate(val while_pred, val gen_fun, val init_val)
 
 static val expand_right_fun(val env, val lcons)
 {
-  cons_bind (pair, gen_fun, env);
-  cons_bind (elem, init_val, pair);
+  us_cons_bind (pair, gen_fun, env);
+  us_cons_bind (elem, init_val, pair);
 
   val next_pair = funcall1(gen_fun, init_val);
 
-  rplaca(lcons, elem);
+  us_rplaca(lcons, elem);
 
   if (next_pair) {
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
-    rplaca(env, next_pair);
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
+    us_rplaca(env, next_pair);
   } else {
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
   }
 
   return nil;
@@ -5714,31 +5714,31 @@ static val nexpand_left(val gen_fun, val init_val)
 
 static val repeat_infinite_func(val env, val lcons)
 {
-  if (!car(env))
-    rplaca(env, cdr(env));
-  rplaca(lcons, pop(valptr(car_l(env))));
-  rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+  if (!us_car(env))
+    us_rplaca(env, cdr(env));
+  us_rplaca(lcons, pop(valptr(car_l(env))));
+  us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
   return nil;
 }
 
 static val repeat_times_func(val env, val lcons)
 {
-  cons_bind (stack, list_count, env);
-  cons_bind (list, count, list_count);
+  us_cons_bind (stack, list_count, env);
+  us_cons_bind (list, count, list_count);
 
   if (!stack) {
-    rplaca(env, list);
-    rplacd(list_count, count = minus(count, one));
+    us_rplaca(env, list);
+    us_rplacd(list_count, count = minus(count, one));
   }
 
-  rplaca(lcons, pop(valptr(car_l(env))));
+  us_rplaca(lcons, pop(valptr(car_l(env))));
 
   if (!car(env) && count == one) {
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
     return nil;
   }
 
-  rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+  us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
   return nil;
 }
 
@@ -5758,19 +5758,19 @@ static val repeat(val list, val count)
 
 static val pad_func(val env, val lcons)
 {
-  cons_bind (list, item_count, env);
+  us_cons_bind (list, item_count, env);
   val next = cdr(list);
 
-  rplaca(lcons, car(list));
+  us_rplaca(lcons, car(list));
 
   if (next && seqp(next)) {
-    rplaca(env, next);
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplaca(env, next);
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
     return nil;
   } else if (!next) {
-    val count = cdr(item_count);
-    rplacd(item_count, nil);
-    rplacd(lcons, repeat(item_count, count));
+    val count = us_cdr(item_count);
+    us_rplacd(item_count, nil);
+    us_rplacd(lcons, repeat(item_count, count));
   } else {
     uw_throwf(error_s, lit("pad: cannot pad improper list terminated by ~s"),
               next, nao);
diff --git a/lib.c b/lib.c
index 64db88e4..bb34f88d 100644
--- a/lib.c
+++ b/lib.c
@@ -748,8 +748,8 @@ val conses(val list)
 
 static val lazy_conses_func(val env, val lcons)
 {
-  val fun = lcons_fun(lcons);
-  rplaca(lcons, env);
+  val fun = us_lcons_fun(lcons);
+  us_rplaca(lcons, env);
   func_set_env(fun, env = cdr(env));
 
   if (env)
@@ -1516,11 +1516,11 @@ static val lazy_appendv_func(val env, val lcons)
   cons_bind (fl, rl, env);
   cons_bind (fe, re, fl);
 
-  rplaca(lcons, fe);
+  us_rplaca(lcons, fe);
 
   if (re) {
-    rplaca(env, re);
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplaca(env, re);
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
   } else if (rl) {
     do {
       fl = car(rl);
@@ -1529,11 +1529,11 @@ static val lazy_appendv_func(val env, val lcons)
 
     if (fl) {
       if (rl) {
-        rplaca(env, fl);
-        rplacd(env, rl);
-        rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+        us_rplaca(env, fl);
+        us_rplacd(env, rl);
+        us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
       } else {
-        rplacd(lcons, fl);
+        us_rplacd(lcons, fl);
       }
     }
   }
@@ -1974,8 +1974,8 @@ static val rem_lazy_rec(val obj, val list, val env, val func);
 static val rem_lazy_func(val env, val lcons)
 {
   cons_bind (pred, list, env);
-  val rest = rem_lazy_rec(pred, list, env, lcons_fun(lcons));
-  rplacd(lcons, rem_lazy_rec(pred, list, env, lcons_fun(lcons)));
+  val rest = rem_lazy_rec(pred, list, env, us_lcons_fun(lcons));
+  us_rplacd(lcons, rem_lazy_rec(pred, list, env, us_lcons_fun(lcons)));
   return rest;
 }
 
@@ -2194,16 +2194,16 @@ static val lazy_flatten_scan(val list, val *escape)
 
 static val lazy_flatten_func(val env, val lcons)
 {
-  cons_bind (list, escape, env);
+  us_cons_bind (list, escape, env);
   val atom = car(list);
   val next = lazy_flatten_scan(cdr(list), &escape);
 
-  rplaca(lcons, atom);
-  rplaca(env, next);
-  rplacd(env, escape);
+  us_rplaca(lcons, atom);
+  us_rplaca(env, next);
+  us_rplacd(env, escape);
 
   if (next)
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
   return nil;
 }
@@ -2250,7 +2250,7 @@ static val lazy_flatcar_scan(val tree, val *cont)
 
 static val lazy_flatcar_func(val env, val lcons)
 {
-  val tree = car(env);
+  val tree = us_car(env);
   val cont = nil;
   val atom = lazy_flatcar_scan(tree, &cont);
 
@@ -2258,7 +2258,7 @@ static val lazy_flatcar_func(val env, val lcons)
   rplaca(env, cont);
 
   if (cont)
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
   return nil;
 }
@@ -2282,8 +2282,8 @@ val lazy_flatcar(val tree)
 static val tuples_func(val env, val lcons)
 {
   list_collect_decl (out, ptail);
-  cons_bind (seq_in, envr, env);
-  cons_bind (n, fill, envr);
+  us_cons_bind (seq_in, envr, env);
+  us_cons_bind (n, fill, envr);
   val seq = seq_in;
   val count;
 
@@ -2294,11 +2294,11 @@ static val tuples_func(val env, val lcons)
     for (; gt(count, zero); count = minus(count, one))
       ptail = list_collect(ptail, fill);
 
-  rplaca(env, seq);
+  us_rplaca(env, seq);
 
   if (seq)
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
-  rplaca(lcons, make_like(out, seq_in));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
+  us_rplaca(lcons, make_like(out, seq_in));
 
   return nil;
 }
@@ -2317,8 +2317,8 @@ val tuples(val n, val seq, val fill)
 static val partition_by_func(val env, val lcons)
 {
   list_collect_decl (out, ptail);
-  cons_bind (flast_seq, func, env);
-  cons_bind (flast, seq_in, flast_seq);
+  us_cons_bind (flast_seq, func, env);
+  us_cons_bind (flast, seq_in, flast_seq);
   val seq = seq_in;
   val fnext = nil;
 
@@ -2337,13 +2337,13 @@ static val partition_by_func(val env, val lcons)
     flast = fnext;
   }
 
-  rplaca(flast_seq, fnext);
-  rplacd(flast_seq, seq);
+  us_rplaca(flast_seq, fnext);
+  us_rplacd(flast_seq, seq);
 
   if (seq)
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
-  rplaca(lcons, make_like(out, seq_in));
+  us_rplaca(lcons, make_like(out, seq_in));
   return nil;
 }
 
@@ -2361,8 +2361,8 @@ val partition_by(val func, val seq)
 
 static val partition_func(val env, val lcons)
 {
-  cons_bind (seq, indices_base, env);
-  cons_bind (indices, base, indices_base);
+  us_cons_bind (seq, indices_base, env);
+  us_cons_bind (indices, base, indices_base);
   val len = nil;
 
   for (;;) {
@@ -2379,17 +2379,17 @@ static val partition_func(val env, val lcons)
         val first = sub(seq, zero, index_rebased);
         val rest = nullify(sub(seq, index_rebased, t));
 
-        rplaca(env, rest);
-        rplaca(indices_base, indices);
-        rplacd(indices_base, index);
+        us_rplaca(env, rest);
+        us_rplaca(indices_base, indices);
+        us_rplacd(indices_base, index);
 
         if (rest)
-          rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+          us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
-        rplaca(lcons, first);
+        us_rplaca(lcons, first);
       }
     } else {
-      rplaca(lcons, seq);
+      us_rplaca(lcons, seq);
     }
     break;
   }
@@ -2399,8 +2399,8 @@ static val partition_func(val env, val lcons)
 
 static val split_func(val env, val lcons)
 {
-  cons_bind (seq, indices_base, env);
-  cons_bind (indices, base, indices_base);
+  us_cons_bind (seq, indices_base, env);
+  us_cons_bind (indices, base, indices_base);
   val len = nil;
 
   for (;;) {
@@ -2418,18 +2418,18 @@ static val split_func(val env, val lcons)
         val rsub = sub(seq, index_rebased, t);
         val rest = nullify(rsub);
 
-        rplaca(env, rest);
-        rplaca(indices_base, indices);
-        rplacd(indices_base, index);
+        us_rplaca(env, rest);
+        us_rplaca(indices_base, indices);
+        us_rplacd(indices_base, index);
 
-        rplacd(lcons, if3(rest,
-                          make_lazy_cons(lcons_fun(lcons)),
-                          cons(rsub, nil)));
+        us_rplacd(lcons, if3(rest,
+                             make_lazy_cons(us_lcons_fun(lcons)),
+                             cons(rsub, nil)));
 
-        rplaca(lcons, first);
+        us_rplaca(lcons, first);
       }
     } else {
-      rplaca(lcons, seq);
+      us_rplaca(lcons, seq);
     }
     break;
   }
@@ -2439,8 +2439,8 @@ static val split_func(val env, val lcons)
 
 static val split_star_func(val env, val lcons)
 {
-  cons_bind (seq, indices_base, env);
-  cons_bind (indices, base, indices_base);
+  us_cons_bind (seq, indices_base, env);
+  us_cons_bind (indices, base, indices_base);
   val len = nil;
 
   for (;;) {
@@ -2458,18 +2458,18 @@ static val split_star_func(val env, val lcons)
         val rsub = sub(seq, succ(index_rebased), t);
         val rest = nullify(rsub);
 
-        rplaca(env, rest);
-        rplaca(indices_base, indices);
-        rplacd(indices_base, succ(index));
+        us_rplaca(env, rest);
+        us_rplaca(indices_base, indices);
+        us_rplacd(indices_base, succ(index));
 
-        rplacd(lcons, if3(rest,
-                          make_lazy_cons(lcons_fun(lcons)),
-                          cons(rsub, nil)));
+        us_rplacd(lcons, if3(rest,
+                             make_lazy_cons(us_lcons_fun(lcons)),
+                             cons(rsub, nil)));
 
-        rplaca(lcons, first);
+        us_rplaca(lcons, first);
       }
     } else {
-      rplaca(lcons, seq);
+      us_rplaca(lcons, seq);
     }
     break;
   }
@@ -2519,8 +2519,8 @@ static val partition_star_func(val env, val lcons)
   val len = nil;
 
   for (;;) {
-    cons_bind (seq, indices_base, env);
-    cons_bind (indices, base, indices_base);
+    us_cons_bind (seq, indices_base, env);
+    us_cons_bind (indices, base, indices_base);
 
     if (indices) {
       val raw_index = pop(&indices);
@@ -2540,19 +2540,19 @@ static val partition_star_func(val env, val lcons)
         pop(&indices);
       }
 
-      rplaca(env, seq);
-      rplaca(indices_base, indices);
-      rplacd(indices_base, base);
+      us_rplaca(env, seq);
+      us_rplaca(indices_base, indices);
+      us_rplacd(indices_base, base);
 
       if (!first)
         continue;
 
-      rplaca(lcons, first);
+      us_rplaca(lcons, first);
 
       if (seq)
-        rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+        us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
     } else {
-      rplaca(lcons, seq);
+      us_rplaca(lcons, seq);
     }
 
     break;
@@ -8543,16 +8543,16 @@ val window_mappend(val range, val boundary, val fun, val seq)
 
 static val lazy_interpose_func(val env, val lcons)
 {
-  cons_bind (sep, list, env);
+  us_cons_bind (sep, list, env);
   val next = cdr(list);
-  val fun = lcons_fun(lcons);
+  val fun = us_lcons_fun(lcons);
 
-  rplaca(lcons, car(list));
+  us_rplaca(lcons, car(list));
 
   if (next) {
-    rplacd(env, next);
+    us_rplacd(env, next);
     func_set_env(fun, env);
-    rplacd(lcons, cons(sep, make_lazy_cons(fun)));
+    us_rplacd(lcons, cons(sep, make_lazy_cons(fun)));
   }
 
   return nil;
@@ -9800,16 +9800,16 @@ val ends_with(val little, val big, val testfun, val keyfun)
 
 static val take_list_fun(val env, val lcons)
 {
-  cons_bind (list, count, env);
+  us_cons_bind (list, count, env);
 
-  rplaca(lcons, pop(&list));
+  us_rplaca(lcons, pop(&list));
 
   if3(le((count = pred(count)), zero) || list == nil,
-      rplacd(lcons, nil),
-      rplacd(lcons, make_lazy_cons(lcons_fun(lcons))));
+      us_rplacd(lcons, nil),
+      us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))));
 
-  rplaca(env, list);
-  rplacd(env, count);
+  us_rplaca(env, list);
+  us_rplacd(env, count);
   return nil;
 }
 
@@ -9835,17 +9835,17 @@ val take(val count, val seq)
 
 static val take_while_list_fun(val env, val lcons)
 {
-  cons_bind (list, cell, env);
-  cons_bind (pred, keyfun, cell);
+  us_cons_bind (list, cell, env);
+  us_cons_bind (pred, keyfun, cell);
 
-  rplaca(lcons, pop(&list));
+  us_rplaca(lcons, pop(&list));
 
   if (!list || !funcall1(pred, funcall1(keyfun, car(list))))
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
   else
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
-  rplaca(env, list);
+  us_rplaca(env, list);
   return nil;
 }
 
@@ -9878,18 +9878,18 @@ val take_while(val pred, val seq, val keyfun)
 
 static val take_until_list_fun(val env, val lcons)
 {
-  cons_bind (list, cell, env);
-  cons_bind (pred, keyfun, cell);
+  us_cons_bind (list, cell, env);
+  us_cons_bind (pred, keyfun, cell);
   val item = pop(&list);
 
-  rplaca(lcons, item);
+  us_rplaca(lcons, item);
 
   if (!list || funcall1(pred, funcall1(keyfun, item)))
-    rplacd(lcons, nil);
+    us_rplacd(lcons, nil);
   else
-    rplacd(lcons, make_lazy_cons(lcons_fun(lcons)));
+    us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)));
 
-  rplaca(env, list);
+  us_rplaca(env, list);
   return nil;
 }
 
@@ -10801,7 +10801,7 @@ static val lazy_where_hash_func(val hash_iter, val lcons)
   }
 
   {
-    val cell = make_lazy_cons(lcons_fun(lcons));
+    val cell = make_lazy_cons(us_lcons_fun(lcons));
     us_rplaca(cell, key);
     us_rplacd(cell, func);
     us_rplacd(lcons, cell);
diff --git a/lib.h b/lib.h
index 70ba864a..bc41ffea 100644
--- a/lib.h
+++ b/lib.h
@@ -668,6 +668,7 @@ void rcyc_cons(val cons);
 void rcyc_list(val list);
 void rcyc_empty(void);
 val lcons_fun(val lcons);
+INLINE val us_lcons_fun(val lcons) { return lcons->lc.func; }
 val list(val first, ...); /* terminated by nao */
 val listv(struct args *);
 val consp(val obj);
@@ -1225,6 +1226,11 @@ loc list_collect_revappend(loc ptail, val obj);
   obj_t *FROM = from(r_n_g ## FROM ## TO);      \
   obj_t *TO = ((r_n_g ## FROM ## TO)->rn.to)
 
+#define us_cons_bind(CAR, CDR, CONS)            \
+  obj_t *c_o_n_s ## CAR ## CDR = CONS;          \
+  obj_t *CAR = us_car(c_o_n_s ## CAR ## CDR);   \
+  obj_t *CDR = us_cdr(c_o_n_s ## CAR ## CDR)
+
 #define zero num_fast(0)
 #define one num_fast(1)
 #define two num_fast(2)