Functional records

I added a data type for "records." A record behaves like a function that maps
string keys to arbitrary values.  It is represented internally as a vector of
zero or more items, each item a {key val} pair, sorted by key.

The expression (empty) returns the empty record.

The expression (set key val obj) sets key to val in record obj, returning a
record like obj but with key mapped to val.  It modifies obj inline if there
are no other references to it; otherwise it returns a modified copy of obj.

The expression (record_count obj) returns the number of items in the record.

The expression (record_item obj pos) returns the item in record obj at offset
pos, starting at zero.

These functions can be used to define record_pairs, which returns the lazy list
of pairs in a record, allowing iteration (see test/record.fxl).

I added a "chain" function, defined by type_chain in basic.c.  The expression
(chain a b x) returns (a x) if that value is defined, otherwise (b x).  This is
used to establish default values when a key is not defined in a record or other
function.

EXAMPLES

This constructs a simple record value:

	(
	set "a" 1;
	set "b" 2;
	set "c" 3;
	set "d" 4;
	set "e" 5;
	empty
	)

This overrides some of the earlier specified values:

	(
	set "c" 33; # maps "c" to 33 instead of 3
	set "b" 22; # maps "b" to 22 instead of 2

	set "a" 1;
	set "b" 2;
	set "c" 3;
	set "d" 4;
	set "e" 5;
	empty
	)

See test/record.fxl for more examples.

Author: chkoreff

src/VERSION

@@ -1 +1 @@
-26.30.1
+26.31.0

src/basic.c

@@ -189,6 +189,22 @@ value type_is_good(value f) { return op_predicate(f,is_good); }
 value type_is_bool(value f) { return op_predicate(f,is_bool); }
 value type_is_list(value f) { return op_predicate(f,is_list); }
 
+/* \chain==(\a\b\x \v=(a x) is_defined v v (b x)) */
+value type_chain(value f)
+	{
+	if (!f->L || !f->L->L || !f->L->L->L) return 0;
+	{
+	value x = arg(f->R);
+	value v = eval(AV(arg(f->L->L->R),x));
+
+	if (v->T != type_void)
+		return v;
+
+	drop(v);
+	return eval(AV(arg(f->L->R),hold(x)));
+	}
+	}
+
 /* Expand the list data f->R inline. */
 value expand(value f)
 	{

src/basic.h

@@ -30,4 +30,5 @@ extern value type_is_void(value f);
 extern value type_is_good(value f);
 extern value type_is_bool(value f);
 extern value type_is_list(value f);
+extern value type_chain(value f);
 extern value expand(value y);

src/build

@@ -52,6 +52,7 @@ make type_num
 make type_output
 make type_parse
 make type_rand
+make type_record
 make type_run
 make type_signal
 make type_standard

src/out/record

@@ -0,0 +1,124 @@
+\out=
+~
+BEG
+= test_1
+count 1
+a = void
+!b = 2
+c = void
+d = void
+e = void
+
+= test_2
+count 1
+a = void
+b = 222
+c = void
+d = void
+e = void
+
+= test_3
+count 1
+a = void
+b = 22
+c = void
+d = void
+e = void
+
+= test_4
+count 4
+a = 1
+b = 2
+c = 33
+d = 44
+e = void
+
+= test_5
+count 5
+a = 1
+b = 2
+c = 33
+d = 44
+e = 5
+
+= test_6
+count 5
+a = 1
+b = 2
+c = 33
+d = 44
+e = 5
+
+= test_7
+obj_3043:
+count 3
+a = void
+b = 2
+c = 3
+d = 44
+e = void
+
+obj_8237:
+count 2
+a = void
+b = void
+c = void
+d = 44
+e = 5
+
+obj_7892:
+count 5
+a = 1
+b = 2
+c = 33
+d = 44
+e = 5
+
+= test_8
+count void
+a = 1
+b = 2
+c = 3
+d = void
+e = void
+
+steps 476 bytes 4608
+= test_9
+0
+void
+count 4
+a = 1
+b = void
+c = 33
+d = 44
+e = 5
+
+at "x" = void
+at void = void
+at -1 = {"a" 1}
+at 2.6 = {"d" 44}
+at 99 = void
+at 0 = {"a" 1}
+at 1 = {"c" 33}
+at 2 = {"d" 44}
+at 3 = {"e" 5}
+at 4 = void
+[
+{"a" 1}
+{"c" 33}
+{"d" 44}
+{"e" 5}
+]
+[
+{"a" 1}
+{"c" 33}
+{"d" 44}
+{"e" 5}
+]
+steps 3729 bytes 8384
+END
+~
+\err=
+~
+~
+\status=0

src/show.c

@@ -18,6 +18,7 @@
 #include <type_output.h>
 #include <type_parse.h>
 #include <type_rand.h>
+#include <type_record.h>
 #include <type_run.h>
 #include <type_standard.h>
 #include <type_str.h>
@@ -174,6 +175,8 @@ static void put_type(type t)
 	else if (t == type_split_obj) put("split_obj");
 	else if (t == type_fetch) put("fetch");
 
+	else if (t == type_record) put("record");
+
 	else put_ch('?');
 	}
 
@@ -219,6 +222,21 @@ static void show_form(struct form *form)
 	limit_show(form->exp);
 	}
 
+static void show_record(struct record *x)
+	{
+	unsigned long i;
+	for (i = 0; i < x->count; i++)
+		{
+		struct item *item = &x->item[i];
+		put_ch('[');
+		limit_show(item->key);
+		put_ch(' ');
+		limit_show(item->val);
+		put_ch(']');
+		put_ch(' ');
+		}
+	}
+
 static void show_atom(value f)
 	{
 	if (f->T == type_num)
@@ -233,6 +251,8 @@ static void show_atom(value f)
 		put_ulong(fileno(get_fh(f)));
 	else if (f->T == type_form)
 		show_form((struct form *)f->R);
+	else if (f->T == type_record)
+		show_record(get_record(f));
 	else
 		put_ch('?');
 	}

src/test/check.fxl

@@ -66,6 +66,7 @@
 "lib"
 "stream"
 "resolve"
+"record"
 ]
 
 # Gather any individually specified tests.