Rename some files and functions.

10 files changed, 64 insertions, 72 deletions

diff --git a/src/main.zig b/src/main.zig
index faeb534..9cd3049 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -16,13 +16,13 @@ pub fn main() !void {
     while (true) {
         try writer.writeAll("> ");
         try writer.flush();
-        const datum = zisp.io.parser.parse(reader);
+        const datum = zisp.io.parse.fromReader(reader);
         if (datum.eq(zisp.value.eof)) {
             try writer.writeAll("\n");
             return;
         }
         try writer.writeAll("= ");
-        try zisp.io.unparser.unparse(writer, datum);
+        try zisp.io.print.toWriter(writer, datum);
         try writer.writeAll("\n");
         try writer.flush();
     }
diff --git a/src/test/parse.zig b/src/test/parse.zig
index 8c44454..af807b4 100644
--- a/src/test/parse.zig
+++ b/src/test/parse.zig
@@ -12,7 +12,7 @@ pub const Value = value.Value;
 
 fn parse(str: []const u8) Value {
     var fbs = std.Io.Reader.fixed(str);
-    return io.parser.parse(&fbs);
+    return io.parse.fromReader(&fbs);
 }
 
 test "parse empty" {
@@ -115,62 +115,62 @@ test "parse4" {
     try testing.expectEqualStrings("bar", f.slice());
 }
 
-test "unparse" {
+test "print" {
     var buf: [32]u8 = undefined;
     var w = std.Io.Writer.fixed(&buf);
     const v = parse("#foo");
-    try io.unparser.unparse(&w, v);
+    try io.print.toWriter(&w, v);
     try testing.expectEqualStrings("#foo", buf[0..w.end]);
 }
 
-test "unparse2" {
+test "print2" {
     var buf: [128]u8 = undefined;
     var w = std.Io.Writer.fixed(&buf);
     const v = parse("#{foo bar['x]}");
-    try io.unparser.unparse(&w, v);
+    try io.print.toWriter(&w, v);
     try testing.expectEqualStrings(
         "(#HASH #BRACE foo (#JOIN bar #SQUARE (#QUOTE & x)))",
         buf[0..w.end],
     );
 }
 
-fn writeParseResult(str: []const u8) !void {
+fn parseAndPrint(str: []const u8) !void {
     var buf: [64]u8 = undefined;
     var fw = std.Io.File.stderr().writer(gstIo, &buf);
     const w = &fw.interface;
 
     const v = parse(str);
-    try io.unparser.unparse(w, v);
+    try io.print.toWriter(w, v);
     try w.writeByte('\n');
     try w.flush();
 }
 
-test "unparse3" {
-    try writeParseResult("#{foo bar['x](y)(z)}");
+test "print3" {
+    try parseAndPrint("#{foo bar['x](y)(z)}");
 }
 
-test "unparse4" {
-    try writeParseResult("(foo ;~bar)");
+test "print4" {
+    try parseAndPrint("(foo ;~bar)");
 }
 
-test "unparse5" {
-    try writeParseResult("(;~foo foo ;~bar & ;~bar bar ;~bar)");
+test "print5" {
+    try parseAndPrint("(;~foo foo ;~bar & ;~bar bar ;~bar)");
 }
 
-test "unparse6" {
-    try writeParseResult("(foo bar ... baz bat.(qux))");
+test "print6" {
+    try parseAndPrint("(foo bar ... baz bat.(qux))");
 }
 
-test "unparse7" {
-    try writeParseResult("#`(#,(->keyword (syntax->datum #'sym)) & in)");
+test "print7" {
+    try parseAndPrint("#`(#,(->keyword (syntax->datum #'sym)) & in)");
 }
 
 fn parseBench(path: []const u8, iters: usize) !void {
     const file = try std.Io.Dir.cwd().openFile(gstIo, path, .{});
     defer file.close(gstIo);
 
-    var sfa = io.parser.DefaultSfa.init(std.heap.smp_allocator);
-    var parser = try io.parser.initSfa(&sfa);
+    var sfa = io.parse.DefaultSfa.init(std.heap.smp_allocator);
+    var parser = try io.parse.initSfa(&sfa);
     defer parser.deinit();
 
     var timer = try std.time.Timer.start();
diff --git a/src/zisp/io.zig b/src/zisp/io.zig
index 8adf495..bedf07f 100644
--- a/src/zisp/io.zig
+++ b/src/zisp/io.zig
@@ -1,12 +1,8 @@
-pub const parser = @import("io/parser.zig");
-pub const unparser = @import("io/unparser.zig");
+pub const parse = @import("io/parse.zig");
+pub const print = @import("io/print.zig");
 
-pub const decoder = @import("io/decoder.zig");
-pub const encoder = @import("io/encoder.zig");
+pub const decode = @import("io/decode.zig");
+pub const encode = @import("io/encode.zig");
 
-pub const reader = @import("io/reader.zig");
-pub const writer = @import("io/writer.zig");
-
-pub const parse = parser.parse;
-
-// pub const defaultUnparser = ...
+pub const read = @import("io/read.zig");
+pub const write = @import("io/write.zig");
diff --git a/src/zisp/io/decoder.zig b/src/zisp/io/decode.zig
index eb27e20..eb27e20 100644
--- a/src/zisp/io/decoder.zig
+++ b/src/zisp/io/decode.zig
diff --git a/src/zisp/io/encoder.zig b/src/zisp/io/encode.zig
index eb27e20..eb27e20 100644
--- a/src/zisp/io/encoder.zig
+++ b/src/zisp/io/encode.zig
diff --git a/src/zisp/io/parser.zig b/src/zisp/io/parse.zig
index 49d260c..0d7cfa8 100644
--- a/src/zisp/io/parser.zig
+++ b/src/zisp/io/parse.zig
@@ -50,11 +50,11 @@ pub fn initSfa(alloc: anytype) !Parser {
     );
 }
 
-pub fn parse(input: *std.Io.Reader) Value {
-    return _parse(input, true);
+pub fn fromReader(input: *std.Io.Reader) Value {
+    return _fromReader(input, true);
 }
 
-pub fn _parse(
+pub fn _fromReader(
     input: *std.Io.Reader,
     comptime panic: bool,
 ) if (panic) Value else error{ ParseError, OutOfMemory }!Value {
diff --git a/src/zisp/io/unparser.zig b/src/zisp/io/print.zig
index 04184fa..8ef8b21 100644
--- a/src/zisp/io/unparser.zig
+++ b/src/zisp/io/print.zig
@@ -3,59 +3,55 @@ const std = @import("std");
 const gc = @import("../gc.zig");
 const value = @import("../value.zig");
 
-const istr = value.istr;
-const seq = value.seq;
-
 const Value = value.Value;
 
-pub fn unparse(w: *std.Io.Writer, v: Value) anyerror!void {
+pub fn toWriter(w: *std.Io.Writer, v: Value) anyerror!void {
     // zig fmt: off
-    try if (v.isDouble()) unparseDouble(w, v)
-    else if (v.isFixnum()) unparseFixnum(w, v)
-    else if (v.getPtr(.pair)) |p| unparsePair(w, @ptrCast(p))
-    else if (v.getPtr(.seq)) |p| unparseSeq(w, @ptrCast(p))
-    else if (v.isRune()) unparseRune(w, v)
-    else if (v.isChar()) unparseChar(w, v)
-    else if (v.isMisc()) unparseMisc(w, v)
-    else if (v.isSrat()) unparseSrat(w, v)
-    else if (v.isSstr()) unparseSstr(w, v)
+    try if (v.isDouble()) double(w, v)
+    else if (v.isFixnum()) fixnum(w, v)
+    else if (v.getPtr(.pair)) |p| pair(w, @ptrCast(p))
+    else if (v.getPtr(.seq)) |p| seq(w, @ptrCast(p))
+    else if (v.isRune()) rune(w, v)
+    else if (v.isChar()) char(w, v)
+    else if (v.isMisc()) misc(w, v)
+    else if (v.isSrat()) srat(w, v)
+    else if (v.isSstr()) sstr(w, v)
     ;
     // zig fmt: on
-    try w.flush();
 }
 
-fn unparseDouble(w: *std.Io.Writer, v: Value) !void {
+pub fn double(w: *std.Io.Writer, v: Value) !void {
     _ = w;
     _ = v;
     @panic("not implemented");
 }
 
-fn unparseFixnum(w: *std.Io.Writer, v: Value) !void {
+pub fn fixnum(w: *std.Io.Writer, v: Value) !void {
     _ = w;
     _ = v;
     @panic("not implemented");
 }
 
-fn unparseRune(w: *std.Io.Writer, v: Value) !void {
+pub fn rune(w: *std.Io.Writer, v: Value) !void {
     const name = value.rune.unpack(v);
     try w.writeByte('#');
     try w.writeAll(name.slice());
 }
 
-fn unparseSstr(w: *std.Io.Writer, v: Value) !void {
+pub fn sstr(w: *std.Io.Writer, v: Value) !void {
     // TODO: Check if pipes/escapes necessary.
     const str = value.sstr.unpack(v);
     try w.writeAll(str.slice());
 }
 
-fn unparseChar(w: *std.Io.Writer, v: Value) !void {
+pub fn char(w: *std.Io.Writer, v: Value) !void {
     const uc: u21 = value.char.unpack(v);
     var buf: [4]u8 = undefined;
     const len = try std.unicode.utf8Encode(uc, &buf);
     try w.writeAll(buf[0..len]);
 }
 
-fn unparseMisc(w: *std.Io.Writer, v: Value) !void {
+pub fn misc(w: *std.Io.Writer, v: Value) !void {
     try switch (v.bits) {
         value.f.bits => w.writeAll("#f"),
         value.t.bits => w.writeAll("#t"),
@@ -67,37 +63,37 @@ fn unparseMisc(w: *std.Io.Writer, v: Value) !void {
     };
 }
 
-fn unparseSrat(w: *std.Io.Writer, v: Value) !void {
+pub fn srat(w: *std.Io.Writer, v: Value) !void {
     _ = w;
     _ = v;
     @panic("not implemented");
 }
 
-fn unparsePair(w: *std.Io.Writer, p: *[2]Value) !void {
+pub fn pair(w: *std.Io.Writer, p: *[2]Value) !void {
     try w.writeByte('(');
-    try unparse(w, p[0]);
+    try toWriter(w, p[0]);
     var cdr = p[1];
     while (value.pair.check(cdr)) |p2| : (cdr = value.pair.cdr(cdr)) {
         try w.writeByte(' ');
-        try unparse(w, p2[0]);
+        try toWriter(w, p2[0]);
     }
     if (!value.nil.eq(cdr)) {
         try w.writeByte(' ');
         try w.writeByte('&');
         try w.writeByte(' ');
-        try unparse(w, cdr);
+        try toWriter(w, cdr);
     }
     try w.writeByte(')');
 }
 
-fn unparseSeq(w: *std.Io.Writer, s: *seq.Header) !void {
+pub fn seq(w: *std.Io.Writer, s: *value.seq.Header) !void {
     switch (s.type) {
-        .string => try unparseString(w, s),
+        .string => try string(w, s),
         else => @panic("not implemented"),
     }
 }
 
-fn unparseString(w: *std.Io.Writer, s: *seq.Header) !void {
+pub fn string(w: *std.Io.Writer, s: *value.seq.Header) !void {
     // TODO: Check if pipes/escapes necessary.
     try w.writeByte('|');
     try w.writeAll(s.bytes());
diff --git a/src/zisp/io/read.zig b/src/zisp/io/read.zig
new file mode 100644
index 0000000..5fa647e
--- /dev/null
+++ b/src/zisp/io/read.zig
@@ -0,0 +1,10 @@
+const std = @import("std");
+
+const parse = @import("parse.zig");
+const decode = @import("decode.zig");
+
+const Value = @import("../value.zig").Value;
+
+pub fn fromReader(reader: *std.Io.Reader) Value {
+    return decode.decode(parse.fromReader(reader));
+}
diff --git a/src/zisp/io/reader.zig b/src/zisp/io/reader.zig
deleted file mode 100644
index 3465cb3..0000000
--- a/src/zisp/io/reader.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-// See parse.zig for details.
-
-const parser = @import("parser.zig");
-const decoder = @import("decoder.zig");
-
-const Value = @import("../value.zig").Value;
-
-pub fn readCode(input: []const u8) Value {
-    return decoder.decode(parser.parse(input, .code));
-}
diff --git a/src/zisp/io/writer.zig b/src/zisp/io/write.zig
index eb27e20..eb27e20 100644
--- a/src/zisp/io/writer.zig
+++ b/src/zisp/io/write.zig