From ec19948f35d876f5c64814a2905760b2f8763bb4 Mon Sep 17 00:00:00 2001
From: Kaz Kylheku <kaz@kylheku.com>
Date: Sat, 7 Apr 2012 09:25:07 -0700
Subject: Rounding out hash table functionality with lazy lists that can walk
 table content in different ways.

* eval.c (op_dohash): Follow interface change of hash_next.
(eval_init): hash-keys, hash-values, hash-pairs and hash-alist
intrinsics introduced.

* filter.c (trie_compress): Follow interface change of hash_next.

* hash.c (hash_next): Silly interface which takes a pointer to
the iterator has changed to just take the iterator. The function
unambiguously returns nil when the iteration ends, so there
is no need to set the iterator variable to nil.
(maphash): Follows interface change of hash_next.
(hash_keys_lazy, hash_values_lazy, hash_pairs_lazy, hash_alist_lazy):
New static functions.
(hash_keys, hash_values, hash_pairs, hash_alist): New functions.

* hash.h (hash_next): Declaration updated.
(hash_keys, hash_values, hash_pairs, hash_alist): Declared.

* lib.c (make_half_lazy_cons): New way of constructing lazy cons,
with the car field specified.  It simplifies situations when the
previous cons computes the car of the next one. Why hadn't I thought of
this before?

* lib.h (make_half_lazy_cons): Declared.

* txr.1: Doc stubs for new hash functions.

* txr.vim: Highlighting for new hash functions.
---
 hash.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 72 insertions(+), 6 deletions(-)

(limited to 'hash.c')

diff --git a/hash.c b/hash.c
index d0bd4ac5..03967967 100644
--- a/hash.c
+++ b/hash.c
@@ -490,18 +490,16 @@ val hash_begin(val hash)
   return hi_obj;
 }
 
-val hash_next(val *iter)
+val hash_next(val iter)
 {
-  struct hash_iter *hi = (struct hash_iter *) cobj_handle(*iter, hash_iter_s);
+  struct hash_iter *hi = (struct hash_iter *) cobj_handle(iter, hash_iter_s);
   val hash = hi->hash;
   struct hash *h = (struct hash *) hash->co.handle;
   if (hi->cons)
     hi->cons = cdr(hi->cons);
   while (nullp(hi->cons)) {
-    if (++hi->chain >= h->modulus) {
-      *iter = nil;
+    if (++hi->chain >= h->modulus)
       return nil;
-    }
     set(hi->cons, vecref(h->table, num(hi->chain)));
   }
   return car(hi->cons);
@@ -511,7 +509,7 @@ val maphash(val fun, val hash)
 {
   val iter = hash_begin(hash);
   val cell;
-  while ((cell = hash_next(&iter)) != nil)
+  while ((cell = hash_next(iter)) != nil)
     funcall2(fun, car(cell), cdr(cell));
   return nil;
 }
@@ -640,6 +638,74 @@ val hash_construct(val hashv_args, val pairs)
   return hash;
 }
 
+static val hash_keys_lazy(val iter, val lcons)
+{
+  val cell = hash_next(iter);
+  set(lcons->lc.cdr, if2(cell, make_half_lazy_cons(lcons->lc.func, car(cell))));
+  return nil;
+}
+
+val hash_keys(val hash)
+{
+  val iter = hash_begin(hash);
+  val cell = hash_next(iter);
+  if (!cell)
+    return nil;
+  return make_half_lazy_cons(func_f1(iter, hash_keys_lazy), car(cell));
+}
+
+static val hash_values_lazy(val iter, val lcons)
+{
+  val cell = hash_next(iter);
+  set(lcons->lc.cdr, if2(cell, make_half_lazy_cons(lcons->lc.func, cdr(cell))));
+  return nil;
+}
+
+val hash_values(val hash)
+{
+  val iter = hash_begin(hash);
+  val cell = hash_next(iter);
+  if (!cell)
+    return nil;
+  return make_half_lazy_cons(func_f1(iter, hash_values_lazy), cdr(cell));
+}
+
+static val hash_pairs_lazy(val iter, val lcons)
+{
+  val cell = hash_next(iter);
+  set(lcons->lc.cdr, if2(cell, make_half_lazy_cons(lcons->lc.func,
+                                                   cons(car(cell),
+                                                        cons(cdr(cell),
+                                                             nil)))));
+  return nil;
+}
+
+val hash_pairs(val hash)
+{
+  val iter = hash_begin(hash);
+  val cell = hash_next(iter);
+  if (!cell)
+    return nil;
+  return make_half_lazy_cons(func_f1(iter, hash_pairs_lazy),
+                             cons(car(cell), cons(cdr(cell), nil)));
+}
+
+static val hash_alist_lazy(val iter, val lcons)
+{
+  val cell = hash_next(iter);
+  set(lcons->lc.cdr, if2(cell, make_half_lazy_cons(lcons->lc.func, cell)));
+  return nil;
+}
+
+val hash_alist(val hash)
+{
+  val iter = hash_begin(hash);
+  val cell = hash_next(iter);
+  if (!cell)
+    return nil;
+  return make_half_lazy_cons(func_f1(iter, hash_alist_lazy), cell);
+}
+
 void hash_init(void)
 {
   weak_keys_k = intern(lit("weak-keys"), keyword_package);
-- 
cgit v1.2.3