remove the read and write modules from libgu. this simplifies the i/o layer

14 files changed, 261 insertions, 259 deletions

diff --git a/src/runtime/c/pgf/expr.c b/src/runtime/c/pgf/expr.c
index 4e9c3c1c4..b195eeea5 100644
--- a/src/runtime/c/pgf/expr.c
+++ b/src/runtime/c/pgf/expr.c
@@ -931,25 +931,25 @@ pgf_expr_hash(GuHash h, PgfExpr e)
 
 void
 pgf_print_literal(PgfLiteral lit,
-			  GuWriter* wtr, GuExn* err)
+			      GuOut* out, GuExn* err)
 {
 	GuVariantInfo ei = gu_variant_open(lit);
 	switch (ei.tag) {
 	case PGF_LITERAL_STR: {
 		PgfLiteralStr* lit = ei.data;
-        gu_putc('"', wtr, err);
-		gu_string_write(lit->val, wtr, err);
-        gu_putc('"', wtr, err);
+        gu_putc('"', out, err);
+		gu_string_write(lit->val, out, err);
+        gu_putc('"', out, err);
 		break;
     }
     case PGF_LITERAL_INT: {
         PgfLiteralInt* lit = ei.data;
-		gu_printf(wtr, err, "%d", lit->val);
+		gu_printf(out, err, "%d", lit->val);
         break;
     }
 	case PGF_LITERAL_FLT: {
         PgfLiteralFlt* lit = ei.data;
-		gu_printf(wtr, err, "%lf", lit->val);
+		gu_printf(out, err, "%lf", lit->val);
         break;
     }
 	default:
@@ -959,7 +959,7 @@ pgf_print_literal(PgfLiteral lit,
 
 void
 pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
-               GuWriter* wtr, GuExn* err)
+               GuOut* out, GuExn* err)
 {
 	GuVariantInfo ei = gu_variant_open(expr);
 	switch (ei.tag) {
@@ -967,20 +967,20 @@ pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
 		PgfExprAbs* abs = ei.data;
 
 		if (prec > 1) {
-			gu_puts("(", wtr, err);
+			gu_puts("(", out, err);
 		}
 
-		gu_putc('\\', wtr, err);
+		gu_putc('\\', out, err);
 		
 		PgfPrintContext* new_ctxt = ctxt;
 
 		for (;;) {
 			if (abs->bind_type == PGF_BIND_TYPE_IMPLICIT) {
-				gu_putc('{', wtr, err);
+				gu_putc('{', out, err);
 			}
-			gu_string_write(abs->id, wtr, err);
+			gu_string_write(abs->id, out, err);
 			if (abs->bind_type == PGF_BIND_TYPE_IMPLICIT) {
-				gu_putc('}', wtr, err);
+				gu_putc('}', out, err);
 			}
 
 			PgfPrintContext* c = malloc(sizeof(PgfPrintContext));
@@ -991,13 +991,13 @@ pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
 			if (gu_variant_tag(abs->body) != PGF_EXPR_ABS)
 				break;
 				
-			gu_putc(',', wtr, err);
+			gu_putc(',', out, err);
 			
 			abs = gu_variant_data(abs->body);
 		}
 
-		gu_puts(" -> ", wtr, err);
-		pgf_print_expr(abs->body, new_ctxt, 1, wtr, err);
+		gu_puts(" -> ", out, err);
+		pgf_print_expr(abs->body, new_ctxt, 1, out, err);
 
 		while (new_ctxt != ctxt) {
 			PgfPrintContext* next = new_ctxt->next;
@@ -1006,34 +1006,34 @@ pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
 		}
 
 		if (prec > 1) {
-			gu_puts(")", wtr, err);
+			gu_puts(")", out, err);
 		}
 		break;
 	}
 	case PGF_EXPR_APP: {
 		PgfExprApp* app = ei.data;
 		if (prec > 3) {
-			gu_puts("(", wtr, err);
+			gu_puts("(", out, err);
 		}
-		pgf_print_expr(app->fun, ctxt, 3, wtr, err);
-		gu_puts(" ", wtr, err);
-		pgf_print_expr(app->arg, ctxt, 4, wtr, err);
+		pgf_print_expr(app->fun, ctxt, 3, out, err);
+		gu_puts(" ", out, err);
+		pgf_print_expr(app->arg, ctxt, 4, out, err);
 		if (prec > 3) {
-			gu_puts(")", wtr, err);
+			gu_puts(")", out, err);
 		}
 		break;
 	}
 	case PGF_EXPR_LIT: {
 		PgfExprLit* lit = ei.data;
-        pgf_print_literal(lit->lit, wtr, err);
+        pgf_print_literal(lit->lit, out, err);
 		break;
 	}
 	case PGF_EXPR_META:
-		gu_putc('?', wtr, err);
+		gu_putc('?', out, err);
 		break;
 	case PGF_EXPR_FUN: {
 		PgfExprFun* fun = ei.data;
-		gu_string_write(fun->fun, wtr, err);
+		gu_string_write(fun->fun, out, err);
 		break;
 	}
 	case PGF_EXPR_VAR: {
@@ -1046,26 +1046,26 @@ pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
 		}
 		
 		if (c == NULL) {
-			gu_printf(wtr, err, "#%d", evar->var);
+			gu_printf(out, err, "#%d", evar->var);
 		} else {
-			gu_string_write(c->name, wtr, err);
+			gu_string_write(c->name, out, err);
 		}
 		break;
 	}
 	case PGF_EXPR_TYPED: {
 		PgfExprTyped* typed = ei.data;
-		gu_putc('<', wtr, err);
-		pgf_print_expr(typed->expr, ctxt, 0, wtr, err);
-		gu_puts(" : ", wtr, err);
-		pgf_print_type(typed->type, ctxt, 0, wtr, err);
-		gu_putc('>', wtr, err);
+		gu_putc('<', out, err);
+		pgf_print_expr(typed->expr, ctxt, 0, out, err);
+		gu_puts(" : ", out, err);
+		pgf_print_type(typed->type, ctxt, 0, out, err);
+		gu_putc('>', out, err);
 		break;
 	}
 	case PGF_EXPR_IMPL_ARG: {
 		PgfExprImplArg* impl = ei.data;
-		gu_putc('{', wtr, err);
-		pgf_print_expr(impl->expr, ctxt, 0, wtr, err);
-		gu_putc('}', wtr, err);
+		gu_putc('{', out, err);
+		pgf_print_expr(impl->expr, ctxt, 0, out, err);
+		gu_putc('}', out, err);
 		break;
 	}
 	default:
@@ -1075,26 +1075,26 @@ pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec,
 
 PgfPrintContext*
 pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec,
-               GuWriter *wtr, GuExn *err)
+               GuOut *out, GuExn *err)
 {
     if (hypo->bind_type == PGF_BIND_TYPE_IMPLICIT) {
-        gu_puts("({", wtr, err);
-        gu_string_write(hypo->cid, wtr, err);
-        gu_puts("} : ", wtr, err);
-        pgf_print_type(hypo->type, ctxt, 0, wtr, err);
-        gu_puts(")", wtr, err);
+        gu_puts("({", out, err);
+        gu_string_write(hypo->cid, out, err);
+        gu_puts("} : ", out, err);
+        pgf_print_type(hypo->type, ctxt, 0, out, err);
+        gu_puts(")", out, err);
     } else {
         GuPool* tmp_pool = gu_new_pool();
         GuString tmp = gu_str_string("_", tmp_pool);
         
         if (!gu_string_eq(hypo->cid, tmp)) {
-            gu_puts("(", wtr, err);
-            gu_string_write(hypo->cid, wtr, err);
-            gu_puts(" : ", wtr, err);
-            pgf_print_type(hypo->type, ctxt, 0, wtr, err);
-            gu_puts(")", wtr, err);
+            gu_puts("(", out, err);
+            gu_string_write(hypo->cid, out, err);
+            gu_puts(" : ", out, err);
+            pgf_print_type(hypo->type, ctxt, 0, out, err);
+            gu_puts(")", out, err);
         } else {
-            pgf_print_type(hypo->type, ctxt, prec, wtr, err);
+            pgf_print_type(hypo->type, ctxt, prec, out, err);
         }
         
         gu_pool_free(tmp_pool);
@@ -1108,26 +1108,26 @@ pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec,
 
 void
 pgf_print_type(PgfType *type, PgfPrintContext* ctxt, int prec,
-               GuWriter *wtr, GuExn *err)
+               GuOut *out, GuExn *err)
 {
     size_t n_hypos = gu_seq_length(type->hypos);
     
     if (n_hypos > 0) {
-		if (prec > 0) gu_putc('(', wtr, err);
+		if (prec > 0) gu_putc('(', out, err);
 		
 		PgfPrintContext* new_ctxt = ctxt;
 		for (size_t i = 0; i < n_hypos; i++) {
 			PgfHypo *hypo = gu_seq_index(type->hypos, PgfHypo, i);
-			new_ctxt = pgf_print_hypo(hypo, new_ctxt, 1, wtr, err);
+			new_ctxt = pgf_print_hypo(hypo, new_ctxt, 1, out, err);
 
-			gu_puts(" -> ", wtr, err);
+			gu_puts(" -> ", out, err);
 		}
 
-		gu_string_write(type->cid, wtr, err);
+		gu_string_write(type->cid, out, err);
     
 		for (size_t i = 0; i < type->n_exprs; i++) {
-			gu_puts(" ", wtr, err);
-			pgf_print_expr(type->exprs[i], new_ctxt, 4, wtr, err);
+			gu_puts(" ", out, err);
+			pgf_print_expr(type->exprs[i], new_ctxt, 4, out, err);
 		}
 
 		while (new_ctxt != ctxt) {
@@ -1136,20 +1136,20 @@ pgf_print_type(PgfType *type, PgfPrintContext* ctxt, int prec,
 			new_ctxt = next;
 		}
 
-		if (prec > 0) gu_putc(')', wtr, err);
+		if (prec > 0) gu_putc(')', out, err);
 	} else if (type->n_exprs > 0) {
-		if (prec > 3) gu_putc('(', wtr, err);
+		if (prec > 3) gu_putc('(', out, err);
 		
-		gu_string_write(type->cid, wtr, err);
+		gu_string_write(type->cid, out, err);
     
 		for (size_t i = 0; i < type->n_exprs; i++) {
-			gu_puts(" ", wtr, err);
-			pgf_print_expr(type->exprs[i], ctxt, 4, wtr, err);
+			gu_puts(" ", out, err);
+			pgf_print_expr(type->exprs[i], ctxt, 4, out, err);
 		}
 		
-		if (prec > 3) gu_putc(')', wtr, err);
+		if (prec > 3) gu_putc(')', out, err);
 	} else {
-		gu_string_write(type->cid, wtr, err);
+		gu_string_write(type->cid, out, err);
 	}
 }
 
diff --git a/src/runtime/c/pgf/expr.h b/src/runtime/c/pgf/expr.h
index bcfaee52c..485464207 100644
--- a/src/runtime/c/pgf/expr.h
+++ b/src/runtime/c/pgf/expr.h
@@ -1,8 +1,8 @@
 #ifndef EXPR_H_
 #define EXPR_H_
 
-#include <gu/read.h>
-#include <gu/write.h>
+#include <gu/in.h>
+#include <gu/out.h>
 #include <gu/variant.h>
 #include <gu/seq.h>
 
@@ -180,18 +180,18 @@ struct PgfPrintContext {
 };
 
 void
-pgf_print_literal(PgfLiteral lit, GuWriter* wtr, GuExn* err);
+pgf_print_literal(PgfLiteral lit, GuOut* out, GuExn* err);
 
 void
 pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec, 
-               GuWriter* wtr, GuExn* err);
+               GuOut* out, GuExn* err);
 
 PgfPrintContext*
 pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec,
-               GuWriter *wtr, GuExn *err);
+               GuOut* out, GuExn *err);
 
 void
 pgf_print_type(PgfType *type, PgfPrintContext* ctxt, int prec,
-               GuWriter *wtr, GuExn *err);
+               GuOut* out, GuExn *err);
 
 #endif /* EXPR_H_ */
diff --git a/src/runtime/c/pgf/graphviz.c b/src/runtime/c/pgf/graphviz.c
index 7c3ee60c4..005de6ec4 100644
--- a/src/runtime/c/pgf/graphviz.c
+++ b/src/runtime/c/pgf/graphviz.c
@@ -4,7 +4,7 @@
 
 static int
 pgf_graphviz_abstract_tree_(PgfExpr expr, int *pid,
-                            GuWriter* wtr, GuExn* err)
+                            GuOut* out, GuExn* err)
 {
 	int id = -1;
 
@@ -15,52 +15,52 @@ pgf_graphviz_abstract_tree_(PgfExpr expr, int *pid,
 		break;
 	case PGF_EXPR_APP: {
 		PgfExprApp* app = ei.data;
-		id = pgf_graphviz_abstract_tree_(app->fun, pid, wtr, err);
-		int arg_id = pgf_graphviz_abstract_tree_(app->arg, pid, wtr, err);
-		gu_printf(wtr, err, "n%d -- n%d [style = \"solid\"]\n", id, arg_id);
+		id = pgf_graphviz_abstract_tree_(app->fun, pid, out, err);
+		int arg_id = pgf_graphviz_abstract_tree_(app->arg, pid, out, err);
+		gu_printf(out, err, "n%d -- n%d [style = \"solid\"]\n", id, arg_id);
 		break;
 	}
 	case PGF_EXPR_LIT: {
 		PgfExprLit* lit = ei.data;
 		id = (*pid)++;
-		gu_printf(wtr, err, "n%d[label = \"", id);
+		gu_printf(out, err, "n%d[label = \"", id);
 		
 		GuVariantInfo ei = gu_variant_open(lit->lit);
 		switch (ei.tag) {
 		case PGF_LITERAL_STR: {
 			PgfLiteralStr* lit = ei.data;
-			gu_puts("\\\"", wtr, err);
-			gu_string_write(lit->val, wtr, err);
-			gu_puts("\\\"", wtr, err);
+			gu_puts("\\\"", out, err);
+			gu_string_write(lit->val, out, err);
+			gu_puts("\\\"", out, err);
 			break;
 		}
 		case PGF_LITERAL_INT: {
 			PgfLiteralInt* lit = ei.data;
-			gu_printf(wtr, err, "%d", lit->val);
+			gu_printf(out, err, "%d", lit->val);
 			break;
 		}
 		case PGF_LITERAL_FLT: {
 			PgfLiteralFlt* lit = ei.data;
-			gu_printf(wtr, err, "%lf", lit->val);
+			gu_printf(out, err, "%lf", lit->val);
 			break;
 		}
 		default:
 			gu_impossible();
 		}
 
-		gu_puts("\", style = \"solid\", shape = \"plaintext\"]\n", wtr, err);
+		gu_puts("\", style = \"solid\", shape = \"plaintext\"]\n", out, err);
 		break;
 	}
 	case PGF_EXPR_META:
 		id = (*pid)++;
-		gu_printf(wtr, err, "n%d[label = \"?\", style = \"solid\", shape = \"plaintext\"]\n", id);
+		gu_printf(out, err, "n%d[label = \"?\", style = \"solid\", shape = \"plaintext\"]\n", id);
 		break;
 	case PGF_EXPR_FUN: {
 		PgfExprFun* fun = ei.data;
 		id = (*pid)++;
-		gu_printf(wtr, err, "n%d[label = \"", id);
-		gu_string_write(fun->fun, wtr, err);
-		gu_puts("\", style = \"solid\", shape = \"plaintext\"]\n", wtr, err);
+		gu_printf(out, err, "n%d[label = \"", id);
+		gu_string_write(fun->fun, out, err);
+		gu_puts("\", style = \"solid\", shape = \"plaintext\"]\n", out, err);
 		break;
 	}
 	case PGF_EXPR_VAR:
@@ -68,12 +68,12 @@ pgf_graphviz_abstract_tree_(PgfExpr expr, int *pid,
 		break;
 	case PGF_EXPR_TYPED: {
 		PgfExprTyped* typed = ei.data;
-		id = pgf_graphviz_abstract_tree_(typed->expr, pid, wtr, err);
+		id = pgf_graphviz_abstract_tree_(typed->expr, pid, out, err);
 		break;
 	}
 	case PGF_EXPR_IMPL_ARG: {
 		PgfExprImplArg* implarg = ei.data;
-		id = pgf_graphviz_abstract_tree_(implarg->expr, pid, wtr, err);
+		id = pgf_graphviz_abstract_tree_(implarg->expr, pid, out, err);
 		break;
 	}
 	default:
@@ -84,13 +84,13 @@ pgf_graphviz_abstract_tree_(PgfExpr expr, int *pid,
 }
 
 void
-pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, GuWriter* wtr, GuExn* err)
+pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, GuOut* out, GuExn* err)
 {
 	int id = 0;
 
-	gu_puts("graph {\n", wtr, err);
-	pgf_graphviz_abstract_tree_(expr, &id, wtr, err);
-	gu_puts("}", wtr, err);
+	gu_puts("graph {\n", out, err);
+	pgf_graphviz_abstract_tree_(expr, &id, out, err);
+	gu_puts("}", out, err);
 }
 
 typedef struct PgfParseNode PgfParseNode;
@@ -105,7 +105,7 @@ typedef struct {
 	PgfLinFuncs* funcs;
 
 	GuPool* pool;
-	GuWriter* wtr;
+	GuOut* out;
 	GuExn* err;
 	
 	PgfParseNode* parent;
@@ -221,43 +221,43 @@ static PgfLinFuncs pgf_bracket_lin_funcs = {
 };
 
 static void
-pgf_graphviz_parse_level(GuBuf* level, GuWriter* wtr, GuExn* err)
+pgf_graphviz_parse_level(GuBuf* level, GuOut* out, GuExn* err)
 {
-	gu_puts("\n  subgraph {rank=same;\n", wtr, err);
+	gu_puts("\n  subgraph {rank=same;\n", out, err);
 
 	size_t len = gu_buf_length(level);
 	
 	if (len > 1)
-		gu_puts("    edge[style=invis]\n", wtr, err);
+		gu_puts("    edge[style=invis]\n", out, err);
 
 	for (size_t i = 0; i < len; i++) {
 		PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i);
-		gu_printf(wtr, err, "    n%d[label=\"", node->id);
-		gu_string_write(node->label, wtr, err);
-		gu_puts("\"]\n", wtr, err);		
+		gu_printf(out, err, "    n%d[label=\"", node->id);
+		gu_string_write(node->label, out, err);
+		gu_puts("\"]\n", out, err);		
 	}
 	
 	if (len > 1) {
 		for (size_t i = 0; i < len; i++) {
 			PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i);		
 		
-			gu_puts((i == 0) ? "    " : " -- ", wtr, err);
-			gu_printf(wtr, err, "n%d", node->id);
+			gu_puts((i == 0) ? "    " : " -- ", out, err);
+			gu_printf(out, err, "n%d", node->id);
 		}
-		gu_puts("\n", wtr, err);
+		gu_puts("\n", out, err);
 	}
 	
-	gu_puts("  }\n", wtr, err);
+	gu_puts("  }\n", out, err);
 
 	for (size_t i = 0; i < len; i++) {
 		PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i);		
 		if (node->parent != NULL)
-			gu_printf(wtr, err, "  n%d -- n%d\n", node->parent->id, node->id);
+			gu_printf(out, err, "  n%d -- n%d\n", node->parent->id, node->id);
 	}
 }
 
 void
-pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err)
+pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err)
 {
 	GuPool* tmp_pool = gu_local_pool();
 	
@@ -269,13 +269,13 @@ pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err
 		return;
 	}
 
-	gu_puts("graph {\n", wtr, err);
-	gu_puts("  node[shape=plaintext]\n", wtr, err);
+	gu_puts("graph {\n", out, err);
+	gu_puts("  node[shape=plaintext]\n", out, err);
 
 	PgfBracketLznState state;
 	state.funcs = &pgf_bracket_lin_funcs;
 	state.pool = tmp_pool;
-	state.wtr = wtr;
+	state.out = out;
 	state.err = err;
 
 	state.parent    = NULL;
@@ -288,11 +288,11 @@ pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err
 	size_t len = gu_buf_length(state.internals);
 	for (size_t i = 0; i < len; i++) {
 		GuBuf* level = gu_buf_get(state.internals, GuBuf*, i);
-		pgf_graphviz_parse_level(level, wtr, err);
+		pgf_graphviz_parse_level(level, out, err);
 	}
-	pgf_graphviz_parse_level(state.leaves, wtr, err);
+	pgf_graphviz_parse_level(state.leaves, out, err);
 
-	gu_puts("}", wtr, err);
+	gu_puts("}", out, err);
 
 	gu_pool_free(tmp_pool);
 }
diff --git a/src/runtime/c/pgf/graphviz.h b/src/runtime/c/pgf/graphviz.h
index 6f34bf500..650ce4830 100644
--- a/src/runtime/c/pgf/graphviz.h
+++ b/src/runtime/c/pgf/graphviz.h
@@ -2,9 +2,9 @@
 #define PGF_GRAPHVIZ_H_
 
 void
-pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, GuWriter* wtr, GuExn* err);
+pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, GuOut* out, GuExn* err);
 
 void
-pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err);
+pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err);
 
 #endif
diff --git a/src/runtime/c/pgf/lexer.c b/src/runtime/c/pgf/lexer.c
index d50098072..5f3867af3 100644
--- a/src/runtime/c/pgf/lexer.c
+++ b/src/runtime/c/pgf/lexer.c
@@ -1,11 +1,12 @@
 #include <gu/list.h>
+#include <gu/utf8.h>
 #include <pgf/pgf.h>
 #include <pgf/data.h>
 #include <wctype.h>
 
 typedef struct {
 	PgfLexer base;
-	GuReader* rdr;
+	GuIn* in;
 	GuPool* pool;
 	GuUCS ucs;
 } PgfSimpleLexer;
@@ -13,7 +14,7 @@ typedef struct {
 static void
 pgf_lexer_read_ucs(PgfSimpleLexer *lexer, GuExn* err)
 {
-	lexer->ucs = gu_read_ucs(lexer->rdr, err);
+	lexer->ucs = gu_in_utf8(lexer->in, err);
 	if (gu_exn_is_raised(err)) {
 		gu_exn_clear(err);
 		lexer->ucs = ' ';
@@ -27,10 +28,10 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 	GuPool* tmp_pool = gu_new_pool();
 
 	GuStringBuf* buf = gu_string_buf(tmp_pool);
-	GuWriter* wtr = gu_string_buf_writer(buf);
+	GuOut* out = gu_string_buf_out(buf);
 
 	while (iswspace(lexer->ucs)) {
-		lexer->ucs = gu_read_ucs(lexer->rdr, err);
+		lexer->ucs = gu_in_utf8(lexer->in, err);
 		if (gu_exn_is_raised(err))
 			goto stop;
 	}
@@ -40,7 +41,7 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 	    lexer->ucs == '_') {
 		int counter = 0;
 		do {
-			gu_ucs_write(lexer->ucs, wtr, err);
+			gu_out_utf8(lexer->ucs, out, err);
 			if (gu_exn_is_raised(err))
 				goto stop;
 			counter++;
@@ -48,7 +49,7 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 
 			if (lexer->ucs == '.' && counter < 4) {
 				// perhaps an abreviation
-				gu_ucs_write(lexer->ucs, wtr, err);
+				gu_out_utf8(lexer->ucs, out, err);
 				if (gu_exn_is_raised(err))
 					goto stop;
 				counter = 0;
@@ -59,7 +60,7 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 		         lexer->ucs == '_');
 	} else if (iswdigit(lexer->ucs) || lexer->ucs == '-') {
 		if (lexer->ucs == '-') {
-			gu_ucs_write(lexer->ucs, wtr, err);
+			gu_out_utf8(lexer->ucs, out, err);
 			if (gu_exn_is_raised(err))
 				goto stop;
 				
@@ -69,7 +70,7 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 		}
 
 		do {
-			gu_ucs_write(lexer->ucs, wtr, err);
+			gu_out_utf8(lexer->ucs, out, err);
 			if (gu_exn_is_raised(err))
 				goto stop;
 
@@ -77,20 +78,20 @@ pgf_simple_lexer_read_token(PgfLexer *base, GuExn* err)
 		} while (iswdigit(lexer->ucs));
 		
 		if (lexer->ucs == '.') {
-			gu_ucs_write(lexer->ucs, wtr, err);
+			gu_out_utf8(lexer->ucs, out, err);
 			if (gu_exn_is_raised(err))
 				goto stop;
 
 			pgf_lexer_read_ucs(lexer, err);
 			while (iswdigit(lexer->ucs)) {
-				gu_ucs_write(lexer->ucs, wtr, err);
+				gu_out_utf8(lexer->ucs, out, err);
 				if (gu_exn_is_raised(err))
 					goto stop;
 				pgf_lexer_read_ucs(lexer, err);
 			}
 		}
 	} else {
-		gu_ucs_write(lexer->ucs, wtr, err);
+		gu_out_utf8(lexer->ucs, out, err);
 		if (gu_exn_is_raised(err))
 			goto stop;
 		pgf_lexer_read_ucs(lexer, err);
@@ -104,12 +105,12 @@ stop:
 }
 
 PgfLexer*
-pgf_new_simple_lexer(GuReader *rdr, GuPool *pool)
+pgf_new_simple_lexer(GuIn *in, GuPool *pool)
 {
 	PgfSimpleLexer* lexer = gu_new(PgfSimpleLexer, pool);
 	lexer->base.read_token = pgf_simple_lexer_read_token;
 	lexer->base.tok = gu_empty_string;
-	lexer->rdr = rdr;
+	lexer->in = in;
 	lexer->pool = pool;
 	lexer->ucs = ' ';	
 	return ((PgfLexer*) lexer);
diff --git a/src/runtime/c/pgf/lexer.h b/src/runtime/c/pgf/lexer.h
index 5a0323332..b55c07930 100644
--- a/src/runtime/c/pgf/lexer.h
+++ b/src/runtime/c/pgf/lexer.h
@@ -1,7 +1,7 @@
 #ifndef PGF_LEXER_H_
 #define PGF_LEXER_H_
 
-#include <gu/read.h>
+#include <gu/in.h>
 #include <pgf/expr.h>
 
 /// A single lexical token			      
@@ -20,7 +20,7 @@ typedef struct {
 } PgfLexer;
 
 PgfLexer*
-pgf_new_simple_lexer(GuReader *rdr, GuPool *pool);
+pgf_new_simple_lexer(GuIn *in, GuPool *pool);
 
 PgfToken
 pgf_lexer_read_token(PgfLexer *lexer, GuExn* err);
diff --git a/src/runtime/c/pgf/linearizer.c b/src/runtime/c/pgf/linearizer.c
index 81d2529c7..9626c0ebd 100644
--- a/src/runtime/c/pgf/linearizer.c
+++ b/src/runtime/c/pgf/linearizer.c
@@ -367,11 +367,11 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
 				GuPool* tmp_pool = gu_local_pool();
 				GuExn* err = gu_new_exn(NULL, gu_kind(type), tmp_pool);
 				GuStringBuf* sbuf = gu_string_buf(tmp_pool);
-				GuWriter* wtr = gu_string_buf_writer(sbuf);
+				GuOut* out = gu_string_buf_out(sbuf);
 
-				gu_putc('[', wtr, err);
-				gu_string_write(efun->fun, wtr, err);
-				gu_putc(']', wtr, err);
+				gu_putc('[', out, err);
+				gu_string_write(efun->fun, out, err);
+				gu_putc(']', out, err);
 				GuString s = gu_string_buf_freeze(sbuf, pool);
 
 				if (ccat != NULL) {
@@ -594,7 +594,7 @@ typedef struct PgfSimpleLin PgfSimpleLin;
 struct PgfSimpleLin {
 	PgfLinFuncs* funcs;
 	int n_tokens;
-	GuWriter* wtr;
+	GuOut* out;
 	GuExn* err;
 };
 
@@ -608,10 +608,10 @@ pgf_file_lzn_symbol_tokens(PgfLinFuncs** funcs, PgfTokens toks)
 	size_t len = gu_seq_length(toks);
 	for (size_t i = 0; i < len; i++) {
 		if (flin->n_tokens > 0)
-			gu_putc(' ', flin->wtr, flin->err);
+			gu_putc(' ', flin->out, flin->err);
 
 		PgfToken tok = gu_seq_get(toks, PgfToken, i);
-		gu_string_write(tok, flin->wtr, flin->err);
+		gu_string_write(tok, flin->out, flin->err);
 		
 		flin->n_tokens++;
 	}
@@ -626,23 +626,23 @@ pgf_file_lzn_expr_literal(PgfLinFuncs** funcs, PgfLiteral lit)
 	}
 
 	if (flin->n_tokens > 0)
-		gu_putc(' ', flin->wtr, flin->err);
+		gu_putc(' ', flin->out, flin->err);
 
 	GuVariantInfo i = gu_variant_open(lit);
     switch (i.tag) {
     case PGF_LITERAL_STR: {
         PgfLiteralStr* lstr = i.data;
-		gu_string_write(lstr->val, flin->wtr, flin->err);
+		gu_string_write(lstr->val, flin->out, flin->err);
 		break;
 	}
     case PGF_LITERAL_INT: {
         PgfLiteralInt* lint = i.data;
-		gu_printf(flin->wtr, flin->err, "%d", lint->val);
+		gu_printf(flin->out, flin->err, "%d", lint->val);
 		break;
 	}
     case PGF_LITERAL_FLT: {
         PgfLiteralFlt* lflt = i.data;
-		gu_printf(flin->wtr, flin->err, "%lf", lflt->val);
+		gu_printf(flin->out, flin->err, "%lf", lflt->val);
 		break;
 	}
 	default:
@@ -661,12 +661,12 @@ static PgfLinFuncs pgf_file_lin_funcs = {
 
 void
 pgf_lzr_linearize_simple(PgfConcr* concr, PgfCncTree ctree,
-			 size_t lin_idx, GuWriter* wtr, GuExn* err)
+			 size_t lin_idx, GuOut* out, GuExn* err)
 {
 	PgfSimpleLin flin = {
 		.funcs = &pgf_file_lin_funcs,
 		.n_tokens = 0,
-		.wtr = wtr,
+		.out = out,
 		.err = err
 	};
 	pgf_lzr_linearize(concr, ctree, lin_idx, &flin.funcs);
diff --git a/src/runtime/c/pgf/linearizer.h b/src/runtime/c/pgf/linearizer.h
index 844436f8d..85a28ef41 100644
--- a/src/runtime/c/pgf/linearizer.h
+++ b/src/runtime/c/pgf/linearizer.h
@@ -75,4 +75,4 @@ pgf_lzr_linearize(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx,
 /// Linearize a concrete syntax tree as space-separated tokens.
 void
 pgf_lzr_linearize_simple(PgfConcr* concr, PgfCncTree ctree,
-			 size_t lin_idx, GuWriter* wtr, GuExn* err);
+			 size_t lin_idx, GuOut* out, GuExn* err);
diff --git a/src/runtime/c/pgf/literals.c b/src/runtime/c/pgf/literals.c
index e1c9ad880..b8e35ea64 100644
--- a/src/runtime/c/pgf/literals.c
+++ b/src/runtime/c/pgf/literals.c
@@ -1,4 +1,5 @@
-#include <gu/read.h>
+#include <gu/in.h>
+#include <gu/utf8.h>
 #include <pgf/parser.h>
 #include <pgf/literals.h>
 #include <wctype.h>
@@ -192,25 +193,25 @@ pgf_match_name_lit(PgfConcr* concr, PgfItem* item, PgfToken tok,
 	if (gu_string_eq(tok, hyp)) {
 		iscap = true;
 	} else if (!gu_string_eq(tok, gu_empty_string)) {
-		GuReader* rdr = gu_string_reader(tok, tmp_pool);
-		iscap = iswupper(gu_read_ucs(rdr, err));
+		GuIn* in = gu_string_in(tok, tmp_pool);
+		iscap = iswupper(gu_in_utf8(in, err));
 	}
 
 	size_t n_syms = gu_seq_length(seq);
 	if (!iscap && n_syms > 0) {
 		GuStringBuf *sbuf = gu_string_buf(tmp_pool);
-		GuWriter* wtr = gu_string_buf_writer(sbuf);
+		GuOut* out = gu_string_buf_out(sbuf);
 
 		for (size_t i = 0; i < n_syms; i++) {
 			if (i > 0)
-			  gu_putc(' ', wtr, err);
+			  gu_putc(' ', out, err);
 
 			PgfSymbol sym = gu_seq_get(seq, PgfSymbol, i);
 			gu_assert(gu_variant_tag(sym) == PGF_SYMBOL_KS);
 			PgfSymbolKS* sks = gu_variant_data(sym);
 			PgfToken tok = gu_seq_get(sks->tokens, PgfToken, 0);
 
-			gu_string_write(tok, wtr, err);
+			gu_string_write(tok, out, err);
 		}
 
 		PgfExprProb* ep = gu_new(PgfExprProb, pool);
diff --git a/src/runtime/c/pgf/parser.c b/src/runtime/c/pgf/parser.c
index 7ca9babd8..47880e874 100644
--- a/src/runtime/c/pgf/parser.c
+++ b/src/runtime/c/pgf/parser.c
@@ -1828,7 +1828,7 @@ pgf_get_tokens(PgfSequence seq,
 	GuPool* tmp_pool = gu_new_pool();
 	GuExn* err = gu_new_exn(NULL, gu_kind(type), tmp_pool);
 	GuStringBuf* sbuf = gu_string_buf(tmp_pool);
-	GuWriter* wtr = gu_string_buf_writer(sbuf);
+	GuOut* out = gu_string_buf_out(sbuf);
 
 	// collect the tokens in the production
 	size_t len = gu_seq_length(seq);
@@ -1842,11 +1842,11 @@ pgf_get_tokens(PgfSequence seq,
 			size_t len = gu_seq_length(symks->tokens);
 			for (size_t i = tok_idx; i < len; i++) {
 				if (i > 0) {
-					gu_putc(' ', wtr, err);
+					gu_putc(' ', out, err);
 				}
 
 				PgfToken tok = gu_seq_get(symks->tokens, PgfToken, i);
-				gu_string_write(tok, wtr, err);						
+				gu_string_write(tok, out, err);						
 			}
 			
 			tok_idx = 0;
diff --git a/src/runtime/c/pgf/pgf.c b/src/runtime/c/pgf/pgf.c
index a03759314..13195c33e 100644
--- a/src/runtime/c/pgf/pgf.c
+++ b/src/runtime/c/pgf/pgf.c
@@ -223,7 +223,7 @@ pgf_print_name(PgfConcr* concr, PgfCId id)
 }
 
 void
-pgf_linearize(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err)
+pgf_linearize(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err)
 {
 	GuPool* tmp_pool = gu_local_pool();
 	
@@ -231,7 +231,7 @@ pgf_linearize(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err)
 		pgf_lzr_concretize(concr, expr, tmp_pool);
 	PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool);
 	if (!gu_variant_is_null(ctree)) {
-		pgf_lzr_linearize_simple(concr, ctree, 0, wtr, err);
+		pgf_lzr_linearize_simple(concr, ctree, 0, out, err);
 	}
 
 	gu_pool_free(tmp_pool);
diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h
index 51998c7b8..9a88cebff 100644
--- a/src/runtime/c/pgf/pgf.h
+++ b/src/runtime/c/pgf/pgf.h
@@ -118,7 +118,7 @@ GuString
 pgf_print_name(PgfConcr*, PgfCId id);
 
 void
-pgf_linearize(PgfConcr* concr, PgfExpr expr, GuWriter* wtr, GuExn* err);
+pgf_linearize(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err);
 
 PgfExprEnum*
 pgf_parse(PgfConcr* concr, PgfCId cat, PgfLexer *lexer, 
@@ -166,6 +166,6 @@ pgf_generate_all(PgfPGF* pgf, PgfCId cat, GuPool* pool);
 /// @}
 
 void
-pgf_print(PgfPGF* pgf, GuWriter* wtr, GuExn* err); 
+pgf_print(PgfPGF* pgf, GuOut* out, GuExn* err); 
 
 #endif // PGF_H_
diff --git a/src/runtime/c/pgf/printer.c b/src/runtime/c/pgf/printer.c
index b0822e577..e9365d0fc 100644
--- a/src/runtime/c/pgf/printer.c
+++ b/src/runtime/c/pgf/printer.c
@@ -3,7 +3,7 @@
 
 typedef struct {
 	GuMapItor fn;
-	GuWriter* wtr;
+	GuOut* out;
 } PgfPrintFn;
 
 void
@@ -13,13 +13,13 @@ pgf_print_flag(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     PgfCId flag = *((PgfCId *) key);
     PgfLiteral lit = *((PgfLiteral *) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
     
-    gu_puts("  flag ", wtr, err);
-    gu_string_write(flag, wtr, err);
-    gu_puts(" = ", wtr, err);
-    pgf_print_literal(lit, wtr, err);
-    gu_puts(";\n", wtr, err);
+    gu_puts("  flag ", out, err);
+    gu_string_write(flag, out, err);
+    gu_puts(" = ", out, err);
+    pgf_print_literal(lit, out, err);
+    gu_puts(";\n", out, err);
 }
 
 void
@@ -29,17 +29,17 @@ pgf_print_cat(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     PgfCId name = *((PgfCId *) key);
     PgfAbsCat *cat  = *((PgfAbsCat **) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
 
-    gu_puts("  cat ", wtr, err);
-    gu_string_write(name, wtr, err);
+    gu_puts("  cat ", out, err);
+    gu_string_write(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(' ', wtr, err);
-		ctxt = pgf_print_hypo(hypo, ctxt, 4, wtr, err);
+		gu_putc(' ', out, err);
+		ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err);
 	}
 
 	while (ctxt != NULL) {
@@ -48,7 +48,7 @@ pgf_print_cat(GuMapItor* fn, const void* key, void* value,
 		ctxt = next;
 	}
 
-    gu_printf(wtr, err, " ;   -- %f\n",cat->meta_prob);
+    gu_printf(out, err, " ;   -- %f\n",cat->meta_prob);
 }
 
 void
@@ -58,31 +58,31 @@ pgf_print_absfun(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     PgfCId name = *((PgfCId *) key);
     PgfAbsFun *fun = *((PgfAbsFun **) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
     
-    gu_puts(gu_seq_is_null(fun->defns) ? "  data " : "  fun ", wtr, err);
-    gu_string_write(name, wtr, err);
-    gu_puts(" : ", wtr, err);
-    pgf_print_type(fun->type, NULL, 0, wtr, err);
-    gu_printf(wtr, err, " ;   -- %f\n", fun->ep.prob);
+    gu_puts(gu_seq_is_null(fun->defns) ? "  data " : "  fun ", out, err);
+    gu_string_write(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);
 }
 static void
-pgf_print_abstract(PgfAbstr* abstr, GuWriter* wtr, GuExn* err)
+pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err)
 {
-	gu_puts("abstract ", wtr, err);
-	gu_string_write(abstr->name, wtr, err);
-	gu_puts(" {\n", wtr, err);
+	gu_puts("abstract ", out, err);
+	gu_string_write(abstr->name, out, err);
+	gu_puts(" {\n", out, err);
 	
-	PgfPrintFn clo1 = { { pgf_print_flag }, wtr };
+	PgfPrintFn clo1 = { { pgf_print_flag }, out };
 	gu_map_iter(abstr->aflags, &clo1.fn, err);
 
-	PgfPrintFn clo2 = { { pgf_print_cat }, wtr };
+	PgfPrintFn clo2 = { { pgf_print_cat }, out };
 	gu_map_iter(abstr->cats, &clo2.fn, err);
 
-	PgfPrintFn clo3 = { { pgf_print_absfun }, wtr };
+	PgfPrintFn clo3 = { { pgf_print_absfun }, out };
 	gu_map_iter(abstr->funs, &clo3.fn, err);
 	
-	gu_puts("}\n", wtr, err);
+	gu_puts("}\n", out, err);
 }
 
 static void
@@ -92,24 +92,24 @@ pgf_print_productions(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     int fid = *((int *) key);
     PgfCCat* ccat = *((PgfCCat**) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
 
 	if (!gu_seq_is_null(ccat->prods)) {
 		size_t n_prods = gu_seq_length(ccat->prods);
 		for (size_t i = 0; i < n_prods; i++) {
 			PgfProduction prod = gu_seq_get(ccat->prods, PgfProduction, i);
 		
-			gu_printf(wtr,err,"    C%d -> ",fid);
+			gu_printf(out,err,"    C%d -> ",fid);
 
 			GuVariantInfo i = gu_variant_open(prod);
 			switch (i.tag) {
 			case PGF_PRODUCTION_APPLY: {
 				PgfProductionApply* papp = i.data;
-				gu_printf(wtr,err,"F%d[",papp->fun->funid);
+				gu_printf(out,err,"F%d[",papp->fun->funid);
 				size_t n_args = gu_seq_length(papp->args);
 				for (size_t j = 0; j < n_args; j++) {
 					if (j > 0)
-						gu_putc(',',wtr,err);
+						gu_putc(',',out,err);
                     
 					PgfPArg arg = gu_seq_get(papp->args, PgfPArg, j);
 
@@ -117,20 +117,20 @@ pgf_print_productions(GuMapItor* fn, const void* key, void* value,
 						size_t n_hypos = gu_list_length(arg.hypos);
 						for (size_t k = 0; k < n_hypos; k++) {
 							if (k > 0)
-								gu_putc(' ',wtr,err);
+								gu_putc(' ',out,err);
 							PgfCCat *hypo = gu_list_index(arg.hypos, k);
-							gu_printf(wtr,err,"C%d",hypo->fid);
+							gu_printf(out,err,"C%d",hypo->fid);
 						}
 					}
             
-					gu_printf(wtr,err,"C%d",arg.ccat->fid);
+					gu_printf(out,err,"C%d",arg.ccat->fid);
 				}
-				gu_printf(wtr,err,"]\n");
+				gu_printf(out,err,"]\n");
 				break;
 			}
 			case PGF_PRODUCTION_COERCE: {
 				PgfProductionCoerce* pcoerce = i.data;
-				gu_printf(wtr,err,"_[C%d]\n",pcoerce->coerce->fid);
+				gu_printf(out,err,"_[C%d]\n",pcoerce->coerce->fid);
 				break;
 			}
 			default:
@@ -147,119 +147,119 @@ pgf_print_lindefs(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     int fid = *((int *) key);
     PgfCCat* ccat = *((PgfCCat**) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
     
     if (ccat->lindefs != NULL) {
-		gu_printf(wtr,err,"    C%d -> ",fid);
+		gu_printf(out,err,"    C%d -> ",fid);
 		
 		size_t n_lindefs = gu_list_length(ccat->lindefs);
 		for (size_t i = 0; i < n_lindefs; i++) {
-			if (i > 0) gu_putc(' ', wtr, err);
+			if (i > 0) gu_putc(' ', out, err);
 			
 			PgfCncFun* fun = gu_list_index(ccat->lindefs, i);
-			gu_printf(wtr,err,"F%d",fun->funid);
+			gu_printf(out,err,"F%d",fun->funid);
 		}
 		
-		gu_putc('\n', wtr,err);
+		gu_putc('\n', out,err);
 	}
 }
 
 static void
 pgf_print_cncfun(PgfCncFun *cncfun, PgfSequences *sequences, 
-					GuWriter *wtr, GuExn *err)
+					GuOut *out, GuExn *err)
 {
-	gu_printf(wtr,err,"    F%d := (", cncfun->funid);
+	gu_printf(out,err,"    F%d := (", cncfun->funid);
 	
 	size_t n_seqs = gu_list_length(sequences);
 	
 	for (size_t i = 0; i < cncfun->n_lins; i++) {
-		if (i > 0) gu_putc(',', wtr, err);
+		if (i > 0) gu_putc(',', out, err);
 		PgfSequence seq = cncfun->lins[i];
 
 		for (size_t seqid = 0; seqid < n_seqs; seqid++) {
 			if (gu_seq_data(gu_list_index(sequences, seqid)) == gu_seq_data(seq)) {
-				gu_printf(wtr,err,"S%d", seqid);
+				gu_printf(out,err,"S%d", seqid);
 				break;
 			}
 		}
 	}
 	
-	gu_puts(")", wtr, err);
+	gu_puts(")", out, err);
 	
 	if (cncfun->absfun != NULL) {
-		gu_puts(" [", wtr, err);
-		gu_string_write(cncfun->absfun->name, wtr, err);
-		gu_puts("]", wtr, err);
+		gu_puts(" [", out, err);
+		gu_string_write(cncfun->absfun->name, out, err);
+		gu_puts("]", out, err);
 	}
 	
-	gu_puts("\n", wtr, err);
+	gu_puts("\n", out, err);
 }
 
 static void
-pgf_print_tokens(PgfTokens tokens, GuWriter *wtr, GuExn *err)
+pgf_print_tokens(PgfTokens tokens, GuOut *out, GuExn *err)
 {
-	gu_putc('"', wtr, err);
+	gu_putc('"', out, err);
 	size_t n_toks = gu_seq_length(tokens);
 	for (size_t i = 0; i < n_toks; i++) {
-		if (i > 0) gu_putc(' ', wtr, err);
+		if (i > 0) gu_putc(' ', out, err);
 			
 		PgfToken tok = gu_seq_get(tokens, PgfToken, i);
-		gu_string_write(tok, wtr, err);
+		gu_string_write(tok, out, err);
 	}
-	gu_putc('"', wtr, err);
+	gu_putc('"', out, err);
 }
 
 void
-pgf_print_symbol(PgfSymbol sym, GuWriter *wtr, GuExn *err)
+pgf_print_symbol(PgfSymbol sym, GuOut *out, GuExn *err)
 {
 	switch (gu_variant_tag(sym)) {
 	case PGF_SYMBOL_CAT: {
 		PgfSymbolCat* scat = gu_variant_data(sym);
-		gu_printf(wtr, err, "<%d,%d>", scat->d, scat->r);
+		gu_printf(out, err, "<%d,%d>", scat->d, scat->r);
 		break;
 	}
 	case PGF_SYMBOL_KS: {
 		PgfSymbolKS* sks = gu_variant_data(sym);
-		pgf_print_tokens(sks->tokens, wtr, err);
+		pgf_print_tokens(sks->tokens, out, err);
 		break;
 	}
 	case PGF_SYMBOL_KP: {
 		PgfSymbolKP* skp = gu_variant_data(sym);
 
-		gu_puts("pre {", wtr, err);
-		pgf_print_tokens(skp->default_form, wtr, err);
+		gu_puts("pre {", out, err);
+		pgf_print_tokens(skp->default_form, out, err);
 		
 		for (size_t i = 0; i < skp->n_forms; i++) {
-			gu_puts("; ", wtr, err);
-            pgf_print_tokens(skp->forms[i].form, wtr, err);
-            gu_puts(" / ", wtr, err);
+			gu_puts("; ", out, err);
+            pgf_print_tokens(skp->forms[i].form, out, err);
+            gu_puts(" / ", out, err);
             
             size_t n_prefixes = gu_list_length(skp->forms[i].prefixes);
             for (size_t j = 0; j < n_prefixes; j++) {
-				if (j > 0) gu_putc(' ', wtr, err);
+				if (j > 0) gu_putc(' ', out, err);
 				
 				GuString prefix = gu_list_index(skp->forms[i].prefixes, j);
-				gu_putc('"', wtr, err);
-				gu_string_write(prefix, wtr, err);
-				gu_putc('"', wtr, err);
+				gu_putc('"', out, err);
+				gu_string_write(prefix, out, err);
+				gu_putc('"', out, err);
 			}
 		}
 		
-		gu_puts("}", wtr, err);
+		gu_puts("}", out, err);
 		break;
 	}
 	case PGF_SYMBOL_LIT: {
 		PgfSymbolLit *slit = gu_variant_data(sym);
-		gu_printf(wtr, err, "{%d,%d}", slit->d, slit->r);
+		gu_printf(out, err, "{%d,%d}", slit->d, slit->r);
 		break;
 	}
 	case PGF_SYMBOL_VAR: {
 		PgfSymbolVar *svar = gu_variant_data(sym);
-		gu_printf(wtr, err, "<%d,$%d>", svar->d, svar->r);
+		gu_printf(out, err, "<%d,$%d>", svar->d, svar->r);
 		break;
 	}
 	case PGF_SYMBOL_NE: {
-		gu_puts("nonExist", wtr, err);
+		gu_puts("nonExist", out, err);
 		break;
 	}
 	default:
@@ -268,19 +268,19 @@ pgf_print_symbol(PgfSymbol sym, GuWriter *wtr, GuExn *err)
 }
 
 static void
-pgf_print_sequence(size_t seqid, PgfSequence seq, GuWriter *wtr, GuExn *err)
+pgf_print_sequence(size_t seqid, PgfSequence seq, GuOut *out, GuExn *err)
 {
-	gu_printf(wtr,err,"    S%d := ", seqid);
+	gu_printf(out,err,"    S%d := ", seqid);
 
 	int n_syms = gu_seq_length(seq);
 	for (int i = 0; i < n_syms; i++) {
-		if (i > 0) gu_putc(' ', wtr, err);
+		if (i > 0) gu_putc(' ', out, err);
 			
 		PgfSymbol sym = gu_seq_get(seq, PgfSymbol, i);
-		pgf_print_symbol(sym, wtr, err);
+		pgf_print_symbol(sym, out, err);
 	}
 
-	gu_putc('\n', wtr, err);
+	gu_putc('\n', out, err);
 }
 
 static void
@@ -290,66 +290,66 @@ pgf_print_cnccat(GuMapItor* fn, const void* key, void* value,
 	PgfPrintFn* clo = (PgfPrintFn*) fn;
     PgfCId name = *((PgfCId *) key);
     PgfCncCat* cnccat = *((PgfCncCat**) value);
-    GuWriter *wtr = clo->wtr;
+    GuOut *out = clo->out;
     
-    gu_puts("    ", wtr, err);
-    gu_string_write(name, wtr, err);
-    gu_puts(" :=\n", wtr, err);
+    gu_puts("    ", out, err);
+    gu_string_write(name, out, err);
+    gu_puts(" :=\n", out, err);
     
     PgfCCat *start = gu_list_index(cnccat->cats, 0);
     PgfCCat *end   = gu_list_index(cnccat->cats, gu_list_length(cnccat->cats)-1);
     
-    gu_printf(wtr, err, "       range  [C%d..C%d]\n", start->fid, end->fid);
+    gu_printf(out, err, "       range  [C%d..C%d]\n", start->fid, end->fid);
     
-    gu_puts("       labels [", wtr, err);
+    gu_puts("       labels [", out, err);
     for (size_t i = 0; i < cnccat->n_lins; i++) {
 		if (i > 0) {
-			gu_puts("\n               ", wtr, err);
+			gu_puts("\n               ", out, err);
 		}
 
-		gu_string_write(cnccat->labels[i], wtr, err);
+		gu_string_write(cnccat->labels[i], out, err);
 	}
-    gu_puts("]\n", wtr, err);
+    gu_puts("]\n", out, err);
 }
 
 static void
 pgf_print_concrete(PgfCId cncname, PgfConcr* concr, 
-                   GuWriter* wtr, GuExn* err)
+                   GuOut* out, GuExn* err)
 {
-	gu_puts("concrete ", wtr, err);
-	gu_string_write(cncname, wtr, err);
-	gu_puts(" {\n", wtr, err);
+	gu_puts("concrete ", out, err);
+	gu_string_write(cncname, out, err);
+	gu_puts(" {\n", out, err);
 
-	PgfPrintFn clo1 = { { pgf_print_flag }, wtr };
+	PgfPrintFn clo1 = { { pgf_print_flag }, out };
 	gu_map_iter(concr->cflags, &clo1.fn, err);
 
-	gu_puts("  productions\n", wtr, err);
-	PgfPrintFn clo2 = { { pgf_print_productions }, wtr };
+	gu_puts("  productions\n", out, err);
+	PgfPrintFn clo2 = { { pgf_print_productions }, out };
 	gu_map_iter(concr->ccats, &clo2.fn, err);
 
-	gu_puts("  lindefs\n", wtr, err);
-	PgfPrintFn clo3 = { { pgf_print_lindefs }, wtr };
+	gu_puts("  lindefs\n", out, err);
+	PgfPrintFn clo3 = { { pgf_print_lindefs }, out };
 	gu_map_iter(concr->ccats, &clo3.fn, err);
 
-	gu_puts("  lin\n", wtr, err);
+	gu_puts("  lin\n", out, err);
 	size_t n_funs = gu_list_length(concr->cncfuns);
 	for (size_t i = 0; i < n_funs; i++) {
 		PgfCncFun* cncfun = gu_list_index(concr->cncfuns, i);
-		pgf_print_cncfun(cncfun, concr->sequences, wtr, err);
+		pgf_print_cncfun(cncfun, concr->sequences, out, err);
 	}
 
-	gu_puts("  sequences\n", wtr, err);
+	gu_puts("  sequences\n", out, err);
 	size_t n_seqs = gu_list_length(concr->sequences);
 	for (size_t i = 0; i < n_seqs; i++) {
 		PgfSequence seq = gu_list_index(concr->sequences, i);
-		pgf_print_sequence(i, seq, wtr, err);
+		pgf_print_sequence(i, seq, out, err);
 	}
 	
-	gu_puts("  categories\n", wtr, err);
-	PgfPrintFn clo4 = { { pgf_print_cnccat }, wtr };
+	gu_puts("  categories\n", out, err);
+	PgfPrintFn clo4 = { { pgf_print_cnccat }, out };
 	gu_map_iter(concr->cnccats, &clo4.fn, err);
 	
-	gu_puts("}\n", wtr, err);
+	gu_puts("}\n", out, err);
 }
 
 static void
@@ -360,14 +360,14 @@ pgf_print_concr_cb(GuMapItor* fn, const void* key, void* value,
     PgfCId cncname = *((PgfCId *) key);
     PgfConcr *concr = *((PgfConcr **) value);
 
-	pgf_print_concrete(cncname, concr, clo->wtr, err);
+	pgf_print_concrete(cncname, concr, clo->out, err);
 }
 
 void
-pgf_print(PgfPGF* pgf, GuWriter* wtr, GuExn* err)
+pgf_print(PgfPGF* pgf, GuOut* out, GuExn* err)
 {
-	pgf_print_abstract(&pgf->abstract, wtr, err);
+	pgf_print_abstract(&pgf->abstract, out, err);
 	
-	PgfPrintFn clo = { { pgf_print_concr_cb }, wtr };
+	PgfPrintFn clo = { { pgf_print_concr_cb }, out };
 	gu_map_iter(pgf->concretes, &clo.fn, err);
 }
diff --git a/src/runtime/c/pgf/reader.c b/src/runtime/c/pgf/reader.c
index 051459e4c..890749b5b 100644
--- a/src/runtime/c/pgf/reader.c
+++ b/src/runtime/c/pgf/reader.c
@@ -100,13 +100,13 @@ pgf_read_cid(PgfReader* rdr)
 {
 	GuPool* tmp_pool = gu_new_pool();
 	GuStringBuf* sbuf = gu_string_buf(tmp_pool);
-	GuWriter* wtr = gu_string_buf_writer(sbuf);
+	GuOut* out = gu_string_buf_out(sbuf);
 
 	size_t len = pgf_read_len(rdr);
 	for (size_t i = 0; i < len; i++) {
 		// CIds are in latin-1
 		GuUCS ucs = gu_in_u8(rdr->in, rdr->err);
-		gu_ucs_write(ucs, wtr, rdr->err);
+		gu_out_utf8(ucs, out, rdr->err);
 	}
 	GuString str = gu_string_buf_freeze(sbuf, tmp_pool);
 	
@@ -120,13 +120,13 @@ pgf_read_string(PgfReader* rdr)
 {	
 	GuPool* tmp_pool = gu_new_pool();
 	GuStringBuf* sbuf = gu_string_buf(tmp_pool);
-	GuWriter* wtr = gu_string_buf_writer(sbuf);
+	GuOut* out = gu_string_buf_out(sbuf);
 
 	GuLength len = pgf_read_len(rdr);
 
 	for (size_t i = 0; i < len; i++) {
 		GuUCS ucs = gu_in_utf8(rdr->in, rdr->err);
-		gu_ucs_write(ucs, wtr, rdr->err);
+		gu_out_utf8(ucs, out, rdr->err);
 	}
 	GuString str = gu_string_buf_freeze(sbuf, tmp_pool);
 	GuSymbol sym = gu_symtable_intern(rdr->symtab, str);