replace the hash maps in the abstract syntax with binary search tables

src/runtime/c/pgf/data.c

@@ -34,13 +34,19 @@ GU_DEFINE_TYPE(PgfCncCat, abstract);
 
 GU_DEFINE_TYPE(PgfDummyVariant, GuVariant);
 
-GU_DEFINE_TYPE(PgfFlags, GuStringMap, gu_type(PgfDummyVariant), &gu_null_variant);
+static int
+pgf_flag_cmp_fn(GuOrder* self, const void* p1, const void* p2)
+{
+	(void) self;
+	return strcmp((GuString) p1, ((PgfFlag*) p2)->name);
+}
+
+GuOrder pgf_flag_order[1] = { { pgf_flag_cmp_fn } };
+
 
 GU_DEFINE_TYPE(PgfProductionSeq, abstract);
 GU_DEFINE_TYPE(PgfProductionBuf, abstract);
 
-GU_DEFINE_TYPE(PgfAbsFun, abstract);
-
 static prob_t inf_prob = INFINITY;
 
 GU_DEFINE_TYPE(prob_t, GuFloating, _);
@@ -51,9 +57,35 @@ GU_DEFINE_TYPE(PgfMetaChildMap, GuMap,
 
 GU_DEFINE_TYPE(PgfAbsCat, abstract);
 
+static int
+pgf_abscat_cmp_fn(GuOrder* self, const void* p1, const void* p2)
+{
+	(void) self;
+	return strcmp((GuString) p1, ((PgfAbsCat*) p2)->name);
+}
+
+GuOrder pgf_abscat_order[1] = { { pgf_abscat_cmp_fn } };
+
+static int
+pgf_absfun_cmp_fn(GuOrder* self, const void* p1, const void* p2)
+{
+	(void) self;
+	return strcmp((GuString) p1, ((PgfAbsFun*) p2)->name);
+}
+
+GuOrder pgf_absfun_order[1] = { { pgf_absfun_cmp_fn } };
+
+
 static GuString empty_string = "";
 
 GU_DEFINE_TYPE(
 	PgfPrintNames, PgfCIdMap, gu_type(GuString), &empty_string);
 
-GU_DEFINE_TYPE(PgfConcr, abstract);
+static int
+pgf_concr_cmp_fn(GuOrder* self, const void* p1, const void* p2)
+{
+	(void) self;
+	return strcmp((GuString) p1, ((PgfConcr*) p2)->name);
+}
+
+GuOrder pgf_concr_order[1] = { { pgf_concr_cmp_fn } };

src/runtime/c/pgf/data.h

@@ -13,9 +13,16 @@ extern GU_DECLARE_TYPE(PgfCCat, abstract);
 
 typedef GuSeq PgfCCats;
 
-#define PgfCIdMap GuStringMap			 
-typedef PgfCIdMap PgfFlags; // PgfCId -> PgfLiteral
-extern GU_DECLARE_TYPE(PgfFlags, GuMap);
+#define PgfCIdMap GuStringMap
+
+typedef struct {
+	PgfCId name;
+	PgfLiteral value;
+} PgfFlag;
+
+typedef GuSeq PgfFlags;
+
+extern GuOrder pgf_flag_order[1];
 
 // PgfPatt
 
@@ -87,7 +94,9 @@ typedef struct {
 	} closure;
 } PgfAbsFun;
 
-extern GU_DECLARE_TYPE(PgfAbsFun, abstract);
+typedef GuSeq PgfAbsFuns;
+
+extern GuOrder pgf_absfun_order[1];
 
 typedef GuMap PgfMetaChildMap;
 extern GU_DECLARE_TYPE(PgfMetaChildMap, GuMap);
@@ -103,13 +112,18 @@ typedef struct {
 
 extern GU_DECLARE_TYPE(PgfAbsCat, abstract);
 
+typedef GuSeq PgfAbsCats;
+
+extern GuOrder pgf_abscat_order[1];
+
+
 typedef struct PgfEvalGates PgfEvalGates;
 
 typedef struct {
 	PgfCId name;
 	PgfFlags* aflags;
-	PgfCIdMap* funs; // |-> PgfAbsFun*
-	PgfCIdMap* cats; // |-> PgfAbsCat*
+	PgfAbsFuns* funs;
+	PgfAbsCats* cats;
 	PgfAbsFun* abs_lin_fun;
 	PgfEvalGates* eval_gates;
 } PgfAbstr;
@@ -130,12 +144,16 @@ typedef enum {
   PGF_INSTR_FAIL        = 14
 } PgfInstruction;
 
+typedef GuSeq PgfConcrs;
+
+extern GuOrder pgf_concr_order[1];
+
 struct PgfPGF {
 	uint16_t major_version;
 	uint16_t minor_version;
 	PgfFlags* gflags;
 	PgfAbstr abstract;
-	PgfCIdMap* concretes; // |-> PgfConcr*
+	PgfConcrs* concretes;
 	GuPool* pool;         // the pool in which the grammar is allocated
 };
 
@@ -269,7 +287,6 @@ struct PgfConcr {
 	GuFinalizer fin;  // and this is the finalizer in the pool of the whole grammar
 };
 
-extern GU_DECLARE_TYPE(PgfConcr, abstract);
 
 
 // PgfProduction

src/runtime/c/pgf/evaluator.c

@@ -79,7 +79,7 @@ repeat:;
 		PgfExprFun* efun = ei.data;
 
 		PgfAbsFun* absfun =
-			gu_map_get(state->pgf->abstract.funs, efun->fun, PgfAbsFun*);
+			gu_seq_binsearch(state->pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, efun->fun);
 		gu_assert(absfun != NULL);
 
 		if (absfun->closure.code != NULL) {

src/runtime/c/pgf/jit.c

@@ -111,11 +111,11 @@ pgf_jit_read_absfun(PgfReader* rdr, PgfAbstr* abstr)
 
 	PgfCId name = pgf_read_cid(rdr, rdr->tmp_pool);
 	gu_return_on_exn(rdr->err, NULL);
-	
+
 	PgfAbsFun* absfun =
-		gu_map_get(abstr->funs, name, PgfAbsFun*);
+		gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name);
 	assert(absfun != NULL);
-	
+
 	return absfun;
 }
 
@@ -1176,12 +1176,12 @@ pgf_jit_done(PgfReader* rdr, PgfAbstr* abstr)
 			gu_buf_index(rdr->jit_state->call_patches, PgfCallPatch, i);
 
 		PgfAbsCat* arg =
-			gu_map_get(abstr->cats, patch->cid, PgfAbsCat*);
+			gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, patch->cid);
 		if (arg != NULL) {
 			jit_patch_calli(patch->ref,(jit_insn*) arg->predicate);
 		} else {
 			PgfAbsFun* fun =
-				gu_map_get(abstr->funs, patch->cid, PgfAbsFun*);
+				gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, patch->cid);
 			if (fun == NULL)
 				gu_impossible();
 			else  {

src/runtime/c/pgf/parser.c

@@ -1482,54 +1482,48 @@ pgf_parsing_meta_scan(PgfParsing* ps,
 	gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item);
 }
 
-typedef struct {
-	GuMapItor fn;
-	PgfParsing* ps;
-	PgfItem* meta_item;
-} PgfMetaPredictFn;
-
 static void
-pgf_parsing_meta_predict(GuMapItor* fn, const void* key, void* value, GuExn* err)
+pgf_parsing_meta_predict(PgfParsing* ps, PgfItem* meta_item)
 {
-	(void) (err);
+	PgfAbsCats* cats = ps->concr->abstr->cats;
+	size_t n_cats = gu_seq_length(cats);
 	
-	PgfAbsCat* abscat = *((PgfAbsCat**) value);
-    PgfMetaPredictFn* clo = (PgfMetaPredictFn*) fn;
-    PgfParsing* ps = clo->ps;
-    PgfItem* meta_item  = clo->meta_item;
-
-	if (abscat->prob == INFINITY)
-		return;
-
-    PgfCncCat* cnccat =
-		gu_map_get(ps->concr->cnccats, abscat->name, PgfCncCat*);
-	if (cnccat == NULL)
-		return;
-
-	size_t n_cats = gu_seq_length(cnccat->cats);
 	for (size_t i = 0; i < n_cats; i++) {
-		PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i);
-		if (ccat->prods == NULL) {
-			// empty category
+		PgfAbsCat* abscat = gu_seq_index(cats, PgfAbsCat, i);
+
+		if (abscat->prob == INFINITY)
 			continue;
-		}
 
-		for (size_t lin_idx = 0; lin_idx < cnccat->n_lins; lin_idx++) {
-			PgfItem* item = 
-				pgf_item_copy(meta_item, ps);
-			item->inside_prob +=
-				ccat->viterbi_prob+abscat->prob;
+		PgfCncCat* cnccat =
+			gu_map_get(ps->concr->cnccats, abscat->name, PgfCncCat*);
+		if (cnccat == NULL)
+			continue;
 
-			size_t nargs = gu_seq_length(meta_item->args);
-			item->args = gu_new_seq(PgfPArg, nargs+1, ps->pool);
-			memcpy(gu_seq_data(item->args), gu_seq_data(meta_item->args),
-			       nargs * sizeof(PgfPArg));
-			gu_seq_set(item->args, PgfPArg, nargs,
-			           ((PgfPArg) { .hypos = NULL, .ccat = ccat }));
+		size_t n_cats = gu_seq_length(cnccat->cats);
+		for (size_t i = 0; i < n_cats; i++) {
+			PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i);
+			if (ccat->prods == NULL) {
+				// empty category
+				continue;
+			}
 
-			pgf_add_extern_cat(&item->curr_sym, nargs, lin_idx, ps->pool);
+			for (size_t lin_idx = 0; lin_idx < cnccat->n_lins; lin_idx++) {
+				PgfItem* item = 
+					pgf_item_copy(meta_item, ps);
+				item->inside_prob +=
+					ccat->viterbi_prob+abscat->prob;
 
-			gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item);
+				size_t nargs = gu_seq_length(meta_item->args);
+				item->args = gu_new_seq(PgfPArg, nargs+1, ps->pool);
+				memcpy(gu_seq_data(item->args), gu_seq_data(meta_item->args),
+					   nargs * sizeof(PgfPArg));
+				gu_seq_set(item->args, PgfPArg, nargs,
+						   ((PgfPArg) { .hypos = NULL, .ccat = ccat }));
+
+				pgf_add_extern_cat(&item->curr_sym, nargs, lin_idx, ps->pool);
+
+				gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item);
+			}
 		}
 	}
 }
@@ -1833,8 +1827,7 @@ pgf_parsing_item(PgfParsing* ps, PgfItem* item)
 					pgf_parsing_meta_scan(ps, item, meta_token_prob);
 				}
 
-				PgfMetaPredictFn clo = { { pgf_parsing_meta_predict }, ps, item };
-				gu_map_iter(ps->concr->abstr->cats, &clo.fn, NULL);
+				pgf_parsing_meta_predict(ps, item);
 			}
 		} else {
 			pgf_parsing_symbol(ps, item, item->curr_sym);
@@ -1849,28 +1842,28 @@ pgf_parsing_item(PgfParsing* ps, PgfItem* item)
 static void
 pgf_parsing_set_default_factors(PgfParsing* ps, PgfAbstr* abstr)
 {
-	PgfLiteral lit;
+	PgfFlag* flag;
 	
-	lit =
-		gu_map_get(abstr->aflags, "heuristic_search_factor", PgfLiteral);
-	if (!gu_variant_is_null(lit)) {
-		GuVariantInfo pi = gu_variant_open(lit);
+	flag =
+		gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "heuristic_search_factor");
+	if (flag != NULL) {
+		GuVariantInfo pi = gu_variant_open(flag->value);
 		gu_assert (pi.tag == PGF_LITERAL_FLT);
 		ps->heuristic_factor = ((PgfLiteralFlt*) pi.data)->val;
 	}
 
-	lit =
-		gu_map_get(abstr->aflags, "meta_prob", PgfLiteral);
-	if (!gu_variant_is_null(lit)) {
-		GuVariantInfo pi = gu_variant_open(lit);
+	flag =
+		gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "meta_prob");
+	if (flag != NULL) {
+		GuVariantInfo pi = gu_variant_open(flag->value);
 		gu_assert (pi.tag == PGF_LITERAL_FLT);
 		ps->meta_prob = - log(((PgfLiteralFlt*) pi.data)->val);
 	}
 
-	lit =
-		gu_map_get(abstr->aflags, "meta_token_prob", PgfLiteral);
-	if (!gu_variant_is_null(lit)) {
-		GuVariantInfo pi = gu_variant_open(lit);
+	flag =
+		gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "meta_token_prob");
+	if (flag != NULL) {
+		GuVariantInfo pi = gu_variant_open(flag->value);
 		gu_assert (pi.tag == PGF_LITERAL_FLT);
 		ps->meta_token_prob = - log(((PgfLiteralFlt*) pi.data)->val);
 	}

src/runtime/c/pgf/pgf.c

@@ -42,15 +42,21 @@ pgf_abstract_name(PgfPGF* pgf)
 }
 
 void
-pgf_iter_languages(PgfPGF* pgf, GuMapItor* fn, GuExn* err)
+pgf_iter_languages(PgfPGF* pgf, GuMapItor* itor, GuExn* err)
 {
-	gu_map_iter(pgf->concretes, fn, err);
+	size_t n_concrs = gu_seq_length(pgf->concretes);
+	for (size_t i = 0; i < n_concrs; i++) {
+		PgfConcr* concr = gu_seq_index(pgf->concretes, PgfConcr, i);
+		itor->fn(itor, concr->name, concr, err);
+		if (!gu_ok(err))
+			break;
+	}
 }
 
 PgfConcr*
 pgf_get_language(PgfPGF* pgf, PgfCId lang)
 {
-	return gu_map_get(pgf->concretes, lang, PgfConcr*);
+	return gu_seq_binsearch(pgf->concretes, pgf_concr_order, PgfConcr, lang);
 }
 
 GuString
@@ -60,21 +66,27 @@ pgf_concrete_name(PgfConcr* concr)
 }
 
 void
-pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err)
+pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err)
 {
-	gu_map_iter(pgf->abstract.cats, fn, err);
+	size_t n_cats = gu_seq_length(pgf->abstract.cats);
+	for (size_t i = 0; i < n_cats; i++) {
+		PgfAbsCat* cat = gu_seq_index(pgf->abstract.cats, PgfAbsCat, i);
+		itor->fn(itor, cat->name, cat, err);
+		if (!gu_ok(err))
+			break;
+	}
 }
 
 PgfCId
 pgf_start_cat(PgfPGF* pgf)
 {
-	PgfLiteral lit =
-		gu_map_get(pgf->abstract.aflags, "startcat", PgfLiteral);
+	PgfFlag* flag =
+		gu_seq_binsearch(pgf->abstract.aflags, pgf_flag_order, PgfFlag, "startcat");
 
-	if (gu_variant_is_null(lit))
+	if (flag == NULL)
 		return "S";
 
-	GuVariantInfo i = gu_variant_open(lit);
+	GuVariantInfo i = gu_variant_open(flag->value);
 	switch (i.tag) {
 	case PGF_LITERAL_STR: {
 		PgfLiteralStr *lstr = (PgfLiteralStr *) i.data;
@@ -88,13 +100,13 @@ pgf_start_cat(PgfPGF* pgf)
 GuString
 pgf_language_code(PgfConcr* concr)
 {
-	PgfLiteral lit =
-		gu_map_get(concr->cflags, "language", PgfLiteral);
+	PgfFlag* flag =
+		gu_seq_binsearch(concr->cflags, pgf_flag_order, PgfFlag, "language");
 
-	if (gu_variant_is_null(lit))
+	if (flag == NULL)
 		return "";
 
-	GuVariantInfo i = gu_variant_open(lit);
+	GuVariantInfo i = gu_variant_open(flag->value);
 	switch (i.tag) {
 	case PGF_LITERAL_STR: {
 		PgfLiteralStr *lstr = (PgfLiteralStr *) i.data;
@@ -106,43 +118,38 @@ pgf_language_code(PgfConcr* concr)
 }
 
 void
-pgf_iter_functions(PgfPGF* pgf, GuMapItor* fn, GuExn* err)
+pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err)
 {
-	gu_map_iter(pgf->abstract.funs, fn, err);
-}
-
-typedef struct {
-	GuMapItor fn;
-	PgfCId catname;
-	GuMapItor* client_fn;
-} PgfFunByCatIter;
-
-static void
-pgf_filter_by_cat(GuMapItor* fn, const void* key, void* value, GuExn* err)
-{
-	(void) (key && err);
-
-	PgfFunByCatIter* clo = (PgfFunByCatIter*) fn;
-	PgfAbsFun* absfun = *((PgfAbsFun**) value);
-	
-	if (strcmp(absfun->type->cid, clo->catname) == 0) {
-		clo->client_fn->fn(clo->client_fn, absfun->name, NULL, err);
+	size_t n_funs = gu_seq_length(pgf->abstract.funs);
+	for (size_t i = 0; i < n_funs; i++) {
+		PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i);
+		itor->fn(itor, fun->name, fun, err);
+		if (!gu_ok(err))
+			break;
 	}
 }
 
 void
 pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname, 
-                          GuMapItor* fn, GuExn* err) 
+                          GuMapItor* itor, GuExn* err) 
 {
-	PgfFunByCatIter clo = { { pgf_filter_by_cat }, catname, fn };
-	gu_map_iter(pgf->abstract.funs, &clo.fn, err);
+	size_t n_funs = gu_seq_length(pgf->abstract.funs);
+	for (size_t i = 0; i < n_funs; i++) {
+		PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i);
+		
+		if (strcmp(fun->type->cid, catname) == 0) {
+			itor->fn(itor, fun->name, fun, err);
+			if (!gu_ok(err))
+				break;
+		}
+	}
 }
 
 PgfType*
 pgf_function_type(PgfPGF* pgf, PgfCId funname) 
 {
 	PgfAbsFun* absfun =
-		gu_map_get(pgf->abstract.funs, funname, PgfAbsFun*);
+		gu_seq_binsearch(pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, funname);
 	if (absfun == NULL)
 		return NULL;
 

src/runtime/c/pgf/pgf.h

@@ -40,7 +40,7 @@ GuString
 pgf_abstract_name(PgfPGF*);
 
 void
-pgf_iter_languages(PgfPGF*, GuMapItor*, GuExn* err);
+pgf_iter_languages(PgfPGF*, GuMapItor* itor, GuExn* err);
 
 PgfConcr*
 pgf_get_language(PgfPGF*, PgfCId lang);
@@ -52,17 +52,17 @@ GuString
 pgf_language_code(PgfConcr* concr);
 
 void
-pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err);
+pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err);
 
 PgfCId
 pgf_start_cat(PgfPGF* pgf);
 
 void
-pgf_iter_functions(PgfPGF* pgf, GuMapItor* fn, GuExn* err);
+pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err);
 
 void
 pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname,
-                          GuMapItor* fn, GuExn* err);
+                          GuMapItor* itor, GuExn* err);
 
 PgfType*
 pgf_function_type(PgfPGF* pgf, PgfCId funname);

src/runtime/c/pgf/printer.c

@@ -7,64 +7,61 @@ typedef struct {
 } PgfPrintFn;
 
 void
-pgf_print_flag(GuMapItor* fn, const void* key, void* value,
-			GuExn* err)
+pgf_print_flags(PgfFlags* flags, GuOut *out, GuExn* err)
 {
-	PgfPrintFn* clo = (PgfPrintFn*) fn;
-    PgfCId flag = (PgfCId) key;
-    PgfLiteral lit = *((PgfLiteral *) value);
-    GuOut *out = clo->out;
-    
-    gu_puts("  flag ", out, err);
-    pgf_print_cid(flag, out, err);
-    gu_puts(" = ", out, err);
-    pgf_print_literal(lit, out, err);
-    gu_puts(";\n", out, err);
+	size_t n_flags = gu_seq_length(flags);
+	for (size_t i = 0; i < n_flags; i++) {
+		PgfFlag* flag = gu_seq_index(flags, PgfFlag, i);
+		
+		gu_puts("  flag ", out, err);
+		pgf_print_cid(flag->name, out, err);
+		gu_puts(" = ", out, err);
+		pgf_print_literal(flag->value, out, err);
+		gu_puts(";\n", out, err);
+	}
 }
 
 void
-pgf_print_cat(GuMapItor* fn, const void* key, void* value,
-			GuExn* err)
+pgf_print_abscats(PgfAbsCats* abscats, GuOut *out, GuExn* err)
 {
-	PgfPrintFn* clo = (PgfPrintFn*) fn;
-    PgfCId name = (PgfCId) key;
-    PgfAbsCat *cat  = *((PgfAbsCat **) value);
-    GuOut *out = clo->out;
+	size_t n_cats = gu_seq_length(abscats);
+	for (size_t i = 0; i < n_cats; i++) {
+		PgfAbsCat *abscat = gu_seq_index(abscats, PgfAbsCat, i);
 
-    gu_puts("  cat ", out, err);
-    pgf_print_cid(name, out, err);
+		gu_puts("  cat ", out, err);
+		pgf_print_cid(abscat->name, out, err);
 
-	PgfPrintContext* ctxt = NULL;
-    size_t n_hypos = gu_seq_length(cat->context);
-    for (size_t i = 0; i < n_hypos; i++) {
-		PgfHypo* hypo = gu_seq_index(cat->context, PgfHypo, i);
-		gu_putc(' ', out, err);
-		ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err);
+		PgfPrintContext* ctxt = NULL;
+		size_t n_hypos = gu_seq_length(abscat->context);
+		for (size_t i = 0; i < n_hypos; i++) {
+			PgfHypo* hypo = gu_seq_index(abscat->context, PgfHypo, i);
+			gu_putc(' ', out, err);
+			ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err);
+		}
+
+		while (ctxt != NULL) {
+			PgfPrintContext* next = ctxt->next;
+			free(ctxt);
+			ctxt = next;
+		}
+
+		gu_printf(out, err, " ;   -- %f\n", abscat->prob);
 	}
-
-	while (ctxt != NULL) {
-		PgfPrintContext* next = ctxt->next;
-		free(ctxt);
-		ctxt = next;
-	}
-
-    gu_printf(out, err, " ;   -- %f\n", cat->prob);
 }
 
 void
-pgf_print_absfun(GuMapItor* fn, const void* key, void* value,
-			GuExn* err)
+pgf_print_absfuns(PgfAbsFuns* absfuns, GuOut *out, GuExn* err)
 {
-	PgfPrintFn* clo = (PgfPrintFn*) fn;
-    PgfCId name = (PgfCId) key;
-    PgfAbsFun *fun = *((PgfAbsFun **) value);
-    GuOut *out = clo->out;
+	size_t n_funs = gu_seq_length(absfuns);
+	for (size_t i = 0; i < n_funs; i++) {
+		PgfAbsFun *absfun = gu_seq_index(absfuns, PgfAbsFun, i);
     
-    gu_puts((fun->defns == NULL) ? "  data " : "  fun ", out, err);
-    pgf_print_cid(name, out, err);
-    gu_puts(" : ", out, err);
-    pgf_print_type(fun->type, NULL, 0, out, err);
-    gu_printf(out, err, " ;   -- %f\n", fun->ep.prob);
+		gu_puts((absfun->defns == NULL) ? "  data " : "  fun ", out, err);
+		pgf_print_cid(absfun->name, out, err);
+		gu_puts(" : ", out, err);
+		pgf_print_type(absfun->type, NULL, 0, out, err);
+		gu_printf(out, err, " ;   -- %f\n", absfun->ep.prob);
+	}
 }
 static void
 pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err)
@@ -72,16 +69,11 @@ pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err)
 	gu_puts("abstract ", out, err);
 	pgf_print_cid(abstr->name, out, err);
 	gu_puts(" {\n", out, err);
-	
-	PgfPrintFn clo1 = { { pgf_print_flag }, out };
-	gu_map_iter(abstr->aflags, &clo1.fn, err);
 
-	PgfPrintFn clo2 = { { pgf_print_cat }, out };
-	gu_map_iter(abstr->cats, &clo2.fn, err);
+	pgf_print_flags(abstr->aflags, out, err);
+	pgf_print_abscats(abstr->cats, out, err);
+	pgf_print_absfuns(abstr->funs, out, err);
 
-	PgfPrintFn clo3 = { { pgf_print_absfun }, out };
-	gu_map_iter(abstr->funs, &clo3.fn, err);
-	
 	gu_puts("}\n", out, err);
 }
 
@@ -331,15 +323,13 @@ pgf_print_cnccat(GuMapItor* fn, const void* key, void* value,
 }
 
 static void
-pgf_print_concrete(PgfCId cncname, PgfConcr* concr, 
-                   GuOut* out, GuExn* err)
+pgf_print_concrete(PgfConcr* concr, GuOut* out, GuExn* err)
 {
 	gu_puts("concrete ", out, err);
-	pgf_print_cid(cncname, out, err);
+	pgf_print_cid(concr->name, out, err);
 	gu_puts(" {\n", out, err);
 
-	PgfPrintFn clo1 = { { pgf_print_flag }, out };
-	gu_map_iter(concr->cflags, &clo1.fn, err);
+	pgf_print_flags(concr->cflags, out, err);
 
 	gu_puts("  productions\n", out, err);
 	PgfPrintFn clo2 = { { pgf_print_productions }, out };
@@ -376,22 +366,14 @@ pgf_print_concrete(PgfCId cncname, PgfConcr* concr,
 	gu_puts("}\n", out, err);
 }
 
-static void
-pgf_print_concr_cb(GuMapItor* fn, const void* key, void* value,
-			GuExn* err)
-{
-	PgfPrintFn* clo = (PgfPrintFn*) fn;
-    PgfCId cncname = (PgfCId) key;
-    PgfConcr *concr = *((PgfConcr **) value);
-
-	pgf_print_concrete(cncname, concr, clo->out, err);
-}
-
 void
 pgf_print(PgfPGF* pgf, GuOut* out, GuExn* err)
 {
 	pgf_print_abstract(&pgf->abstract, out, err);
 	
-	PgfPrintFn clo = { { pgf_print_concr_cb }, out };
-	gu_map_iter(pgf->concretes, &clo.fn, err);
+	size_t n_concrs = gu_seq_length(pgf->concretes);
+	for (size_t i = 0; i < n_concrs; i++) {
+		PgfConcr* concr = gu_seq_index(pgf->concretes, PgfConcr, i);
+		pgf_print_concrete(concr, out, err);
+	}
 }

src/runtime/c/pgf/reader.c

@@ -159,19 +159,18 @@ pgf_read_literal(PgfReader* rdr)
 static PgfFlags*
 pgf_read_flags(PgfReader* rdr)
 {
-	PgfFlags* flags = gu_map_type_new(PgfFlags, rdr->opool);
-
-	GuLength len = pgf_read_len(rdr);
+	GuLength n_flags = pgf_read_len(rdr);
 	gu_return_on_exn(rdr->err, NULL);
 
-	for (size_t i = 0; i < len; i++) {
-		PgfCId name = pgf_read_cid(rdr, rdr->opool);
+	PgfFlags* flags = gu_new_seq(PgfFlag, n_flags, rdr->opool);
+	for (size_t i = 0; i < n_flags; i++) {
+		PgfFlag* flag = gu_seq_index(flags, PgfFlag, i);
+
+		flag->name = pgf_read_cid(rdr, rdr->opool);
 		gu_return_on_exn(rdr->err, NULL);
 
-		PgfLiteral value = pgf_read_literal(rdr);
+		flag->value = pgf_read_literal(rdr);
 		gu_return_on_exn(rdr->err, NULL);
-		
-		gu_map_put(flags, name, PgfLiteral, value);
 	}
 
 	return flags;
@@ -415,10 +414,8 @@ pgf_read_patt(PgfReader* rdr)
 }
 
 static PgfAbsFun*
-pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr)
+pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr, PgfAbsFun* absfun)
 {
-	PgfAbsFun* absfun = gu_new(PgfAbsFun, rdr->opool);
-
 	size_t len = pgf_read_len(rdr);
 
 	PgfExprFun *efun =
@@ -486,33 +483,26 @@ pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr)
 	return absfun;
 }
 					    
-static PgfCIdMap*
+static PgfAbsFuns*
 pgf_read_absfuns(PgfReader* rdr, PgfAbstr* abstr)
 {
-	GuMapType* map_type = (GuMapType*)
-		GU_TYPE_LIT(GuStringMap, _,
-			 		gu_ptr_type(PgfAbsFun),
-					&gu_null_struct);
-	PgfCIdMap* absfuns = gu_map_type_make(map_type, rdr->opool);
-
-	size_t len = pgf_read_len(rdr);
+	size_t n_funs = pgf_read_len(rdr);
 	gu_return_on_exn(rdr->err, NULL);
 
-	for (size_t i = 0; i < len; i++) {
-		PgfAbsFun* absfun = pgf_read_absfun(rdr, abstr);
+	PgfAbsFuns* absfuns = gu_new_seq(PgfAbsFun, n_funs, rdr->opool);
+
+	for (size_t i = 0; i < n_funs; i++) {
+		PgfAbsFun* absfun = gu_seq_index(absfuns, PgfAbsFun, i);
+		pgf_read_absfun(rdr, abstr, absfun);
 		gu_return_on_exn(rdr->err, NULL);
-		
-		gu_map_put(absfuns, absfun->name, PgfAbsFun*, absfun);
 	}
 
 	return absfuns;
 }
 
 static PgfAbsCat*
-pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCIdMap* abscats)
+pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfAbsCat* abscat)
 {
-	PgfAbsCat* abscat = gu_new(PgfAbsCat, rdr->opool);
-
 	abscat->name = pgf_read_cid(rdr, rdr->opool);
 	gu_return_on_exn(rdr->err, NULL);
 
@@ -532,23 +522,18 @@ pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCIdMap* abscats)
 	return abscat;
 }
 
-static PgfCIdMap*
+static PgfAbsCats*
 pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr)
 {
-	GuMapType* map_type = (GuMapType*)
-		GU_TYPE_LIT(GuStringMap, _,
-			 		gu_ptr_type(PgfAbsCat),
-					&gu_null_struct);
-	PgfCIdMap* abscats = gu_map_type_make(map_type, rdr->opool);
-
-	size_t len = pgf_read_len(rdr);
+	size_t n_cats = pgf_read_len(rdr);
 	gu_return_on_exn(rdr->err, NULL);
+	
+	PgfAbsCats* abscats = gu_new_seq(PgfAbsCat, n_cats, rdr->opool);
 
-	for (size_t i = 0; i < len; i++) {
-		PgfAbsCat* abscat = pgf_read_abscat(rdr, abstr, abscats);
+	for (size_t i = 0; i < n_cats; i++) {
+		PgfAbsCat* abscat = gu_seq_index(abscats, PgfAbsCat, i);
+		pgf_read_abscat(rdr, abstr, abscat);
 		gu_return_on_exn(rdr->err, NULL);
-
-		gu_map_put(abscats, abscat->name, PgfAbsCat*, abscat);
 	}
 
 	return abscats;
@@ -562,9 +547,9 @@ pgf_read_abstract(PgfReader* rdr, PgfAbstr* abstract)
 
 	abstract->aflags = pgf_read_flags(rdr);
 	gu_return_on_exn(rdr->err, );
-	
+
 	abstract->eval_gates = pgf_jit_gates(rdr);
-	
+		
 	abstract->funs = pgf_read_absfuns(rdr, abstract);
 	gu_return_on_exn(rdr->err, );
 	
@@ -787,7 +772,7 @@ pgf_read_cncfun(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, int funid)
 	gu_return_on_exn(rdr->err, NULL);
 
 	PgfAbsFun* absfun =
-		gu_map_get(abstr->funs, name, PgfAbsFun*);
+		gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name);
 
 	PgfCncFun* cncfun = gu_new_flex(rdr->opool, PgfCncFun, lins, len);
 	cncfun->absfun = absfun;
@@ -1032,7 +1017,7 @@ pgf_read_cnccat(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, PgfCId name)
 		gu_malloc(rdr->opool, sizeof(PgfCncCat)+n_lins*sizeof(GuString));
 
 	cnccat->abscat = 
-		gu_map_get(abstr->cats, name, PgfAbsCat*);
+		gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, name);
 	gu_assert(cnccat->abscat != NULL);
 
 	int len = last + 1 - first;
@@ -1205,10 +1190,8 @@ gu_concr_fini(GuFinalizer* fin)
 }
 
 static PgfConcr*
-pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr, bool with_content)
+pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, bool with_content)
 {
-	PgfConcr* concr = gu_new(PgfConcr, rdr->opool);
-
 	concr->name = 
 		pgf_read_cid(rdr, rdr->opool);
 	gu_return_on_exn(rdr->err, NULL);
@@ -1284,23 +1267,18 @@ pgf_concrete_unload(PgfConcr* concr)
 	gu_concr_fini(&concr->fin);
 }
 
-static PgfCIdMap*
+static PgfConcrs*
 pgf_read_concretes(PgfReader* rdr, PgfAbstr* abstr, bool with_content)
 {
-	GuMapType* map_type = (GuMapType*)
-		GU_TYPE_LIT(GuStringMap, _,
-			 		gu_ptr_type(PgfConcr),
-					&gu_null_struct);
-	PgfCIdMap* concretes = gu_map_type_make(map_type, rdr->opool);
-
-	size_t len = pgf_read_len(rdr);
+	size_t n_concrs = pgf_read_len(rdr);
 	gu_return_on_exn(rdr->err, NULL);
 
-	for (size_t i = 0; i < len; i++) {
-		PgfConcr* concr = pgf_read_concrete(rdr, abstr, with_content);
-		gu_return_on_exn(rdr->err, NULL);
+	PgfConcrs* concretes = gu_new_seq(PgfConcr, n_concrs, rdr->opool);
 
-		gu_map_put(concretes, concr->name, PgfConcr*, concr);
+	for (size_t i = 0; i < n_concrs; i++) {
+		PgfConcr* concr = gu_seq_index(concretes, PgfConcr, i);
+		pgf_read_concrete(rdr, abstr, concr, with_content);
+		gu_return_on_exn(rdr->err, NULL);
 	}
 
 	return concretes;
@@ -1323,10 +1301,10 @@ pgf_read_pgf(PgfReader* rdr) {
 	gu_return_on_exn(rdr->err, NULL);
 
 	bool with_content =
-		gu_variant_is_null(gu_map_get(pgf->gflags, "split", PgfLiteral));
+		(gu_seq_binsearch(pgf->gflags, pgf_flag_order, PgfFlag, "split") == NULL);
 	pgf->concretes = pgf_read_concretes(rdr, &pgf->abstract, with_content);
 	gu_return_on_exn(rdr->err, NULL);
-	
+
 	pgf->pool = rdr->opool;
 
 	return pgf;

src/runtime/c/pgf/reasoner.c

@@ -399,7 +399,7 @@ pgf_generate_all(PgfPGF* pgf, PgfCId cat, GuPool* pool)
 	answers->outside_prob = 0;
 	gu_map_put(rs->table, cat, PgfAnswers*, answers);
 
-	PgfAbsCat* abscat = gu_map_get(rs->abstract->cats, cat, PgfAbsCat*);
+	PgfAbsCat* abscat = gu_seq_binsearch(rs->abstract->cats, pgf_abscat_order, PgfAbsCat, cat);
 	if (abscat != NULL) {
 		((PgfPredicate) abscat->predicate)(rs, NULL);
 	}

src/runtime/c/pgf/typechecker.c

@@ -292,7 +292,7 @@ pgf_tc_type(PgfTypeChecker* checker, PgfType** pty)
 	PgfType* ty = *pty;
 
 	PgfAbsCat* abs_cat =
-		gu_map_get(checker->abstr->cats, ty->cid, PgfAbsCat*);
+		gu_seq_binsearch(checker->abstr->cats, pgf_abscat_order, PgfAbsCat, ty->cid);
 	if (abs_cat == NULL) {
 		GuExnData* exn = gu_raise(checker->exn, PgfExn);
 		exn->data = (void*)
@@ -459,7 +459,7 @@ pgf_inf_expr(PgfTypeChecker* checker, PgfContext* ctxt, PgfExpr* pe)
 
 		if (ty == NULL) {
 			PgfAbsFun* abs_fun =
-				gu_map_get(checker->abstr->funs, efun->fun, PgfAbsFun*);
+				gu_seq_binsearch(checker->abstr->funs, pgf_absfun_order, PgfAbsFun, efun->fun);
 			if (abs_fun == NULL) {
 				GuExnData* exn = gu_raise(checker->exn, PgfExn);
 				exn->data = (void*)