parser: don't leak on parseTo error

A good idea.

build.zig

@@ -26,6 +26,7 @@ const Example = struct {
 const examples = [_]Example{
     .{ .name = "parse", .file = "examples/parse.zig" },
     .{ .name = "stream", .file = "examples/stream.zig" },
+    .{ .name = "reify", .file = "examples/reify.zig" },
 };
 
 pub fn add_examples(b: *std.build, options: ExampleOptions) void {

examples/parse.zig

@@ -1,3 +1,6 @@
+// This example is dedicated to the public domain or, where that is not possible,
+// licensed under CC0-1.0, available at https://spdx.org/licenses/CC0-1.0.html
+
 const std = @import("std");
 
 const nice = @import("nice");

examples/reify.zig

@@ -0,0 +1,91 @@
+// This example is dedicated to the public domain or, where that is not possible,
+// licensed under CC0-1.0, available at https://spdx.org/licenses/CC0-1.0.html
+
+const std = @import("std");
+
+const nice = @import("nice");
+
+const Example = struct {
+    useful: bool,
+    number: i32,
+    string: []const u8,
+    longstring: [:0]const u8,
+    tuple: struct { bool, i8 },
+    enume: enum { first, second, third },
+    taggart: union(enum) { first: []const u8, second: i32 },
+    exist: ?bool,
+    again: ?bool,
+    array: [5]i16,
+    nested: [3]struct { index: usize, title: []const u8 },
+};
+
+const source =
+    \\useful: true
+    \\number: 0x9001
+    \\string: > salutations, earthen oblate spheroid
+    \\
+    \\longstring:
+    \\	| If, at first, you don't think this string has
+    \\	+ multiple lines, then perhaps you are the one who is
+    \\	# yeah, let's add a newline here
+    \\	> wrong.
+    \\	# and a trailing newline for good measure
+    \\	>
+    \\tuple: [ no, 127 ]
+    \\enume: .third
+    \\taggart:
+    \\	first: string a thing
+    \\list:
+    \\	- I am a list item
+    \\exist: null
+    \\again: true
+    \\array: [ 1, 2, 3, 4, 5 ]
+    \\nested:
+    \\	- { index: 1, title: none }
+    \\	- { index: 2, title: such }
+    \\	- { index: 3, title: luck }
+    \\
+;
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    var diagnostics = nice.Diagnostics{};
+    var loaded = nice.parseBufferTo(Example, allocator, source, &diagnostics, .{}) catch |err| {
+        std.debug.print("row:{d} col:{d}: {s}\n", .{
+            diagnostics.row,
+            diagnostics.line_offset,
+            diagnostics.message,
+        });
+        return err;
+    };
+    defer loaded.deinit();
+
+    std.debug.print("{s} {{\n", .{@typeName(Example)});
+    std.debug.print("    useful: {}\n", .{loaded.value.useful});
+    std.debug.print("    number: {d}\n", .{loaded.value.number});
+    std.debug.print("    string: {s}\n", .{loaded.value.string});
+    std.debug.print("    longstring: {s}\n", .{loaded.value.longstring});
+    std.debug.print("    tuple: {{ {}, {d} }}\n", .{ loaded.value.tuple[0], loaded.value.tuple[1] });
+    std.debug.print("    enume: {s}\n", .{@tagName(loaded.value.enume)});
+    std.debug.print("    taggart: ", .{});
+    switch (loaded.value.taggart) {
+        .first => |val| std.debug.print(".first = {s}\n", .{val}),
+        .second => |val| std.debug.print(".second = {d}\n", .{val}),
+    }
+    std.debug.print("    exist: {?}\n", .{loaded.value.exist});
+    std.debug.print("    again: {?}\n", .{loaded.value.again});
+    std.debug.print("    array: [ ", .{});
+    for (loaded.value.array) |item| {
+        std.debug.print("{d}, ", .{item});
+    }
+    std.debug.print("]\n", .{});
+    std.debug.print("    nested: [\n", .{});
+    for (loaded.value.nested) |item| {
+        std.debug.print("        {{ index: {d}, title: {s} }}\n", .{ item.index, item.title });
+    }
+    std.debug.print("    ]\n", .{});
+    std.debug.print("}}\n", .{});
+}

examples/stream.zig

@@ -1,3 +1,6 @@
+// This example is dedicated to the public domain or, where that is not possible,
+// licensed under CC0-1.0, available at https://spdx.org/licenses/CC0-1.0.html
+
 const std = @import("std");
 
 const nice = @import("nice");

license

@@ -0,0 +1,7 @@
+Copyright 2023 torque@epicyclic.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

readme.md

@@ -84,7 +84,7 @@ The string leader sequence consists of an ASCII character followed by a single A
 
 Note that the leader of the first fragment of a string has no effect on the string, and may be any of the three options, but using `| ` is recommended.
 
-The standard fragment trailer is just the normal literal linefeed character `"\n"`, as shown in the examples above. However, because Nice does not permit trailing whitespace syntactically, a string fragment may use the pipe character `|` as a trailer. If the last character in a string fragment is `|`, it will be stripped from the string while the rest of the line is preserved. Note that due to this, if a string fragment needs to end with a pipe character, it must be doubled, as the last one will be stripped from the fragment.
+The standard fragment trailer is just the normal literal linefeed character `"\n"`, as shown in the examples above. However, because Nice does not permit trailing whitespace syntactically, a string fragment may use the pipe character `|` as a trailer. If the last character in a string fragment is `|`, it will be stripped from the fragment while preserving the rest of the line. If a string fragment needs to end with a pipe character, the pipe must be doubled, as the last `|` will be stripped from the fragment.
 
 ```nice
 | lots of   |
@@ -119,7 +119,7 @@ parses to the following JSON structure:
 ["a list", "containing", "", "several values"]
 ```
 
-There are a couple of new concepts here. The first new concept is demonstrated in the second value, which is an inline string. This is a standard fragment string that appears on the same line after another introducer (either a list item introducer, as in this example, or a map key introducer, which will be demonstrated in the section describing maps). The only difference between an inline string and a normal string as discussed above is that the inline string may is composed of only a single fragment (meaning it cannot be spread across multiple lines). The string leader used has no effect on an inline string, since the leader is not applied.
+There are a couple of new concepts here. The first new concept is demonstrated in the second value, which is an inline string. This is a standard string fragment that appears on the same line after another introducer (either a list item introducer, as in this example, or a map key introducer, which will be demonstrated in the section describing maps). The only difference between an inline string and a normal string as discussed above is that the inline string may is composed of only a single fragment (meaning it cannot be spread across multiple lines). The string leader used has no effect on an inline string, since the leader is not applied.
 
 The other new concept is structural indentation. The fourth list item contains an indented string following a list item introducer that does not contain an inline value. Because the string sequence is indented, it belongs to the list item introduced immediately before it. Note that an indented sequence following an introducer that contains an inline value is a syntactic error. That is, the following document **cannot** be parsed:
 
@@ -195,9 +195,9 @@ Hopefully you agree that readability suffers when a more complex hierarchy is ja
 
 ### Maps
 
-A map is a data structure consisting of a sequence of pairs, with each pair being composed of a key and value. A map may represent a general-purpose pair-based data structure such as a hashtable, or it may represent a strictly defined data type with a fixed number of named fields, like a C `struct`. The keys of the map are exclusively scalars, but the corresponding values may be any Nice type, including scalars, strings, lists, or other maps.
+A map is a data structure consisting of a sequence of pairs, with each pair being composed of a key and value. A map may represent a general-purpose pair-based data structure such as a hashtable, or it may represent a strictly defined data type with a fixed number of named fields, like a C `struct`. The keys of the map are exclusively scalars, but the corresponding values may be any Nice type or scalar, including scalars, strings, lists, or other maps.
 
-A map item is introduced by the key scalar. A key scalar is a scalar value that is terminated with an ASCII colon followed by a space `: `. The `:` is removed from the end of the key scalar when parsing. Key scalars may not begin with a sequence that is used for introducing a different type, which means that map keys cannot start with `#` (comments), `- ` (list item introducer), `+ `, `| `, `> `, (string fragment leaders) `[` (inline lists), or `{` (inline maps). Note that `-`, `+`, `|`, and `>` without a following space may be used to begin map keys unambiguously. However `#`, `[`, and `{` are always forbidden. Additionally, key scalars may not contain a colon `:`. Comments may intersperse map pairs. As with the other introducers, if the key scalar is the only item on a line, it must not have a trailing space.
+A map item is introduced by the key scalar. A key scalar is a scalar value that is terminated with an ASCII colon followed by a space `: `. The `:` is removed from the end of the key scalar when parsing. Key scalars may not begin with a sequence that is used for introducing a different type, which means that map keys cannot start with `#` (comments), `- ` (list item introducer), `+ `, `| `, `> ` (string fragment leaders), `[` (inline lists), or `{` (inline maps). `-`, `+`, `|`, and `>` without a following space may be used to begin map keys unambiguously, but `#`, `[`, and `{` are always forbidden. Additionally, key scalars may not contain a colon `:`. Comments may intersperse map pairs. As with the other introducers, if the key scalar is the only item on a line, it must not have a trailing space.
 
 Enough talk, have an example:
 
@@ -208,9 +208,9 @@ a string:
     + from a map
 inline string: | hello from a map
 a list:
-    - 1
-    - 2
-    - 3
+    - true
+    - false
+    - null
 inline list: [ 1, 2, 3 ]
 a map:
     nested:
@@ -225,8 +225,8 @@ This maps to the following JSON structure:
     "a scalar": "value",
     "a string": "hello from a map",
     "inline string": "hello from a map",
-    "a list": [1, 2, 3],
-    "inline list": [1, 2, 3],
+    "a list": ["true", "false", "null"],
+    "inline list": ["1", "2", "3"],
     "a map": { "nested": { "several": "levels" } },
     "an empty value": ""
 }
@@ -246,18 +246,35 @@ values:        value: 2
 }
 ```
 
-- inline maps
+### Inline Maps
+
+The final syntactic construct is the inline map which is, as its name hopefully suggests, the map equivalent of an inline list. An inline map is introduced by an opening curly brace `{` and closed by an opposing brace `}`. An inline map consists of a sequence of key-value pairs with the keys being separated from the values by the `:` character. An inline map may contain scalars, inline lists, and other inline maps as values, and all of its keys must be scalars. As with inline lists, whitespace surrounding values is ignored, and whitespace preceding keys is also ignored (there must be no whitespace between the key and its following `:`).
+
+```nice
+an example: { this: is, an inline: map }
+nests:
+    - { a list: [ of, { inline: maps } ] }
+```
+
+```JSON
+{
+    "an example": {"this": "is", "an inline": "map"},
+    "nests": [
+        { "a list": [ "of", { "inline": "maps" } ] }
+    ]
+}
+```
 
 
 ## Restrictions
 
-Nice documents must be encoded in valid UTF-8. They must use `LF`-only newlines (`CR` characters are forbidden). Tabs and spaces cannot be mixed for indentation. Indentation *must* adhere to a consistent quantum. Nonprinting ASCII characters are forbidden (specifically, any character less than `0x20` (space) except for `0x09` (horizontal tab) and `0x0A` (newline)). Trailing whitespace, including lines consisting only of whitespace, is forbidden, although empty lines are permitted. Some keys and values cannot be represented (for example, map keys cannot start with the character `#`, though map values can).
+Nice documents must be encoded in valid UTF-8. They must use `LF`-only newlines (`CR` characters are forbidden). Tabs and spaces cannot be mixed for indentation. Indentation *must* adhere to a consistent quantum throughout the whole document, including on comment lines. Nonprinting ASCII characters are forbidden (specifically, any character less than `0x20` (space) except for `0x09` (horizontal tab) and `0x0A` (newline)). Trailing whitespace, including lines consisting only of whitespace, is forbidden, although empty lines are permitted. Some keys and values cannot be represented (for example, map keys cannot start with the character `#`, though map values can).
 
 ## Philosophy
 
 ### Let the Application Interpret Data Types (Bring Your Own Schema)
 
-An arbitrarily structured data format with strict types adds complexity to the parser and cannot possibly cover all necessary types needed for every possible application. For example, numbers in JSON are represented by a sequence of ASCII characters, but they are defined by the format to be restricted to specifying double precision floating point numbers. Of course, it is possible to generate a numeric ASCII sequence that does not fit into a double precision floating point number. If an application needs to represent a 64-bit integer in JSON without producing technically invalid JSON, the value must be serialized as a string, which places the burden of decoding it on the application, since the format cannot represent it as a direct numeric value. The same is true of an RFC 3339 datetime. It's not possible for a format to account for every possible data type that an application may need, so don't bother. Users are encouraged to parse Nice documents directly into well-defined, typed structures. If you're interested, the NestedText documentation contains a [highly comprehensive explanation of why having explicit data types in your serialization format is a futile pursuit][only-strings].
+An arbitrarily structured data format with strict types adds complexity to the parser and cannot possibly cover all necessary types needed for every possible application. For example, numbers in JSON are represented by a sequence of ASCII characters, but they are defined by the format to be restricted to specifying double precision floating point numbers. Of course, it is possible to generate a numeric ASCII sequence that does not fit into a double precision floating point number. If an application needs to represent a 64-bit integer in JSON without producing technically invalid JSON, the value must be serialized as a string, which places the burden of decoding it on the application, since the format cannot represent it as a direct numeric value. The same is true of an RFC 3339 datetime. It's not possible for a format to account for every possible data type that an application may need, so don't bother. Users are encouraged to parse Nice documents directly into well-defined, typed structures. If you're interested, the NestedText documentation contains [several examples of why having strict data types in your serialization format is not as useful as you think][only-strings].
 
 Nice explicitly differentiates between bare scalars and strings so that `null` may be disambiguated and interpreted differently from `"null"`.
 
@@ -271,9 +288,20 @@ Nice has no exhaustive specification or formal grammar. The parser is handwritte
 
 # The Implementation
 
+The Reference™ Nice parser/deserializer is this Zig library. It contains a handwritten nonrecursive parser to a generic data structure (`nice.Value`, a tagged union that can represent a scalar, a string, a list of these generic values, or a map of scalars to these generic values). The included example scripts demonstrate how to use the API. See `examples/parse.zig` for one-shot parsing from a slice. `examples/stream.zig` demonstrates how to parse streaming data that does not require loading a whole document into memory at once. This is slower will generally have a lower peak memory usage (which is mainly driven by the size of the document).
+
+`nice.Value` has a method to recursively be converted into a strongly
+typed user-defined structure. Zig's compile-time reflection is used to generate code to perform appropriate type conversion. There a variety of options which can be used to control specific details of the conversion, which are governed by `nice.parser.Options`. `examples/reify.zig` demonstrates basic use of this functionality.
+
+A reference to a `nice.Diagnostics` object with a lifecycle at least as long as the parser must always be provided when parsing. If the source document could not be parsed, this diagnostic object will contain a human-readable explanation of the invalid syntax in the source document that caused the parser to error.
+
+## Memory Strategy
+
+The parser wraps a user-provided allocator in an arena, which is used for all internal allocations. All parsed values are copied into the arena rather than storing references to the source document. The parse result contains a reference to the arena, which can be used to free all of the data allocated during parsing.
+
 # Disclaimer
 
-Yeah, it's entirely possible you hate this and think it's not in fact a nice format. That's fine, but, unfortunately, you forgot to make a time machine and make me name it something else. And yeah, this is probably impossible to search for.
+It's entirely possible you hate this and think it's not, in fact, a nice data format. That's fine, but, unfortunately, you forgot to make a time machine and go back in time to make me name it something else. And yeah, this is probably impossible to search for.
 
 # FAQ
 
@@ -281,6 +309,16 @@ Q: This is so similar to NestedText, why on earth didn't you just implement that
 
 A: in my opinion, it's extremely stupid that NestedText does not support indentation using tabs. Also, trailing whitespace is 100% satanic (in the bad way). And if an implementation is going to diverge there, it might as well roll in some other ideas, call it a new format, and just ruin the world with one more slightly-incompatible thing.
 
+Q: Why is this documentation kind of bad?
+
+A: I'll be honest, I ran out of steam while writing it. For a format that probably nobody besides me will ever use because there's so much open source code in the world that anything without heavy marketing tends to die in obscurity, it's a lot of work to write down the things I already know. But I have put an FAQ section here, while also indicating nobody has ever asked questions about this. Hmm.
+
+# License
+
+What are you going to do, steal my open-source code? Oh, noooooooooo. Here, let me help you.
+
+Library is licensed MIT, examples are Public Domain/CC0. See file headers and the file `license` in the source tree for details.
+
 [NestedText]: https://nestedtext.org
 [only-strings]: https://nestedtext.org/en/latest/alternatives.html#only-strings
 [YAML]: https://yaml.org

src/linebuffer.zig

@@ -1,3 +1,13 @@
+// Copyright 2023 torque@epicyclic.dev
+//
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
+//
+//    https://spdx.org/licenses/MIT.html
+//
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
+
 const std = @import("std");
 
 const Diagnostics = @import("./parser.zig").Diagnostics;

src/nice.zig

@@ -1,63 +1,12 @@
-// Heavily inspired by, but not quite compatible with, NestedText. Key differences:
+// Copyright 2023 torque@epicyclic.dev
 //
-// - Doesn't support multiline keys (this means map keys cannot start with
-//   ' ', \t, #, {, [, |, or >, and they cannot contain :)
-// - Allows using tabs for indentation (but not mixed tabs/spaces)
-// - Indentation must be quantized consistently throughout the document. e.g.
-//   every nested layer being exactly 2 spaces past its parent. Tabs may
-//   only use one tab per indentation level.
-// - Allows flow-style lists, maps, and strings on the same line as map keys or
-//   list items (i.e. the following are legal):
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
 //
-//      key: {inline: map}
-//      key: [inline, list]
-//      key: > inline string
-//      - {map: item}
-//      - [list, item]
-//      - > inline string
+//    https://spdx.org/licenses/MIT.html
 //
-//   The string case retains the possibility of having an inline map value starting
-//   with {, [, or >
-// - a map keys and list item dashes must be followed by a value or an indented
-//   section to reduce parser quantum state. This means that
-//
-//      foo:
-//      bar: baz
-//
-//   or
-//
-//      -
-//      - qux
-//
-//   are not valid. This can be represented with an inline empty string after foo:
-//
-//      foo: >
-//      bar: baz
-//
-//   or
-//
-//      - >
-//      - qux
-//
-// - newlines are strictly LF, if the parser finds CR, it is an error
-// - blank lines may not contain any whitespace characters except the single LF
-// - Additional string indicator `|` for soft-wrapped strings, i.e.
-//
-//      key: | this is not special
-//      key:
-//        | these lines are
-//        | soft-wrapped
-//
-//   soft-wrapped lines are joined with a ' ' instead of a newline character.
-//   Like multiline strings, the final space is stripped (I guess this is a very
-//   janky way to add trailing whitespace to a string).
-//
-// - terminated strings to allow trailing whitespace:
-//      | this string has trailing whitespace    |
-//      > and so does this one                   |
-// - The parser is both strict and probably sloppy and may have weird edge
-//   cases since I'm slinging code, not writing a spec. For example, tabs are
-//   not trimmed from the values of inline lists/maps
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
 
 const std = @import("std");
 
@@ -65,6 +14,7 @@ pub const buffers = @import("./linebuffer.zig");
 pub const tokenizer = @import("./tokenizer.zig");
 pub const parser = @import("./parser.zig");
 pub const parseBuffer = parser.parseBuffer;
+pub const parseBufferTo = parser.parseBufferTo;
 pub const StreamParser = parser.StreamParser;
 pub const Document = parser.Document;
 pub const Value = parser.Value;

src/parser.zig

@@ -1,3 +1,13 @@
+// Copyright 2023 torque@epicyclic.dev
+//
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
+//
+//    https://spdx.org/licenses/MIT.html
+//
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
+
 const std = @import("std");
 
 const buffers = @import("./linebuffer.zig");
@@ -83,6 +93,15 @@ pub const Options = struct {
     // option to change this.
     null_scalars: []const []const u8 = &.{ "null", "nil", "None" },
 
+    // Only used by the parseTo family of functions.
+    // Choose whether to strip the leading `.` off of expected enum values. By default,
+    // `.enum_field` will be parsed into the enum field `enum_field`, which makes them
+    // look like source code enum literals. Any enum value missing the leading `.` will
+    // result in a conversion error. If set to false, no preprocessing will be done
+    // and enum values will be converted from the literal scalar/string. These two styles
+    // cannot be mixed in a single document.
+    expect_enum_dot: bool = true,
+
     // Only used by the parseTo family of functions.
     // Perform ASCII-case-insensitive comparisons for scalars (i.e. `TRUE` in a document
     // will match `true` in the boolean scalars. Unicode case folding is not currently
@@ -136,6 +155,7 @@ pub fn parseBufferTo(
     options: Options,
 ) !Parsed(T) {
     var doc = try parseBuffer(allocator, buffer, diagnostics, options);
+    errdefer doc.deinit();
     return try doc.convertTo(T, options);
 }
 

src/parser/state.zig

@@ -1,3 +1,13 @@
+// Copyright 2023 torque@epicyclic.dev
+//
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
+//
+//    https://spdx.org/licenses/MIT.html
+//
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
+
 const std = @import("std");
 
 const tokenizer = @import("../tokenizer.zig");

src/parser/value.zig

@@ -1,3 +1,13 @@
+// Copyright 2023 torque@epicyclic.dev
+//
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
+//
+//    https://spdx.org/licenses/MIT.html
+//
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
+
 const std = @import("std");
 
 const Options = @import("../parser.zig").Options;
@@ -67,14 +77,14 @@ pub const Value = union(enum) {
                     inline .scalar, .string => |str, tag| {
                         if (tag == .string and !options.coerce_strings) return error.BadValue;
                         if (options.case_insensitive_scalar_coersion) {
-                            for (options.boolean_strings.truthy) |check|
+                            for (options.boolean_scalars.truthy) |check|
                                 if (std.ascii.eqlIgnoreCase(str, check)) return true;
-                            for (options.boolean_strings.falsy) |check|
+                            for (options.boolean_scalars.falsy) |check|
                                 if (std.ascii.eqlIgnoreCase(str, check)) return false;
                         } else {
-                            for (options.boolean_strings.truthy) |check|
+                            for (options.boolean_scalars.truthy) |check|
                                 if (std.mem.eql(u8, str, check)) return true;
-                            for (options.boolean_strings.falsy) |check|
+                            for (options.boolean_scalars.falsy) |check|
                                 if (std.mem.eql(u8, str, check)) return false;
                         }
 
@@ -108,16 +118,30 @@ pub const Value = union(enum) {
                     //       type to use for this? the problem is that it becomes
                     //       invasive into downstream code. Ultimately this should
                     //       probably be solved in the zig stdlib or similar.
-                    // TODO: This also doesn't handle sentinels properly.
                     switch (self) {
-                        .scalar, .string => |str| return if (ptr.child == u8) str else error.BadValue,
+                        .scalar, .string => |str| {
+                            if (ptr.child == u8) {
+                                if (ptr.sentinel) |sent| {
+                                    var copy = try allocator.allocSentinel(u8, str.len, @as(*const u8, @ptrCast(sent)).*);
+                                    @memcpy(copy, str);
+                                    return copy;
+                                }
+                                return str;
+                            } else {
+                                return error.BadValue;
+                            }
+                        },
                         .list, .inline_list => |lst| {
                             var result = try std.ArrayList(ptr.child).initCapacity(allocator, lst.items.len);
                             errdefer result.deinit();
                             for (lst.items) |item| {
                                 result.appendAssumeCapacity(try item.convertTo(ptr.child, allocator, options));
                             }
-                            return result.toOwnedSlice();
+                            if (ptr.sentinel) |sent| {
+                                return try result.toOwnedSliceSentinel(@as(*align(1) const ptr.child, @ptrCast(sent)).*);
+                            } else {
+                                return try result.toOwnedSlice();
+                            }
                         },
                         else => return error.BadValue,
                     }
@@ -136,7 +160,6 @@ pub const Value = union(enum) {
                 //       type to use for this? the problem is that it becomes
                 //       invasive into downstream code. Ultimately this should
                 //       probably be solved in the zig stdlib or similar.
-                // TODO: This also doesn't handle sentinels properly.
                 switch (self) {
                     .scalar, .string => |str| {
                         if (arr.child == u8 and str.len == arr.len) {
@@ -221,7 +244,14 @@ pub const Value = union(enum) {
                 switch (self) {
                     inline .scalar, .string => |str, tag| {
                         if (tag == .string and !options.coerce_strings) return error.BadValue;
-                        if (std.meta.stringToEnum(T, str)) |value| return value;
+                        const name = if (options.expect_enum_dot) blk: {
+                            if (str.len > 0 and str[0] == '.')
+                                break :blk str[1..]
+                            else
+                                return error.BadValue;
+                        } else str;
+
+                        if (std.meta.stringToEnum(T, name)) |value| return value;
                         if (options.allow_numeric_enums) {
                             const parsed = std.fmt.parseInt(@typeInfo(T).Enum.tag_type, str, 10) catch
                                 return error.BadValue;
@@ -260,10 +290,10 @@ pub const Value = union(enum) {
                     inline .scalar, .string => |str, tag| {
                         if (tag == .string and !options.coerce_strings) return error.BadValue;
                         if (options.case_insensitive_scalar_coersion) {
-                            for (options.null_strings) |check|
+                            for (options.null_scalars) |check|
                                 if (std.ascii.eqlIgnoreCase(str, check)) return null;
                         } else {
-                            for (options.null_strings) |check|
+                            for (options.null_scalars) |check|
                                 if (std.mem.eql(u8, str, check)) return null;
                         }
 

src/tokenizer.zig

@@ -1,3 +1,13 @@
+// Copyright 2023 torque@epicyclic.dev
+//
+// Licensed under the MIT/Expat license. You may not use this file except in
+// compliance with the license. You may obtain a copy of the license at
+//
+//    https://spdx.org/licenses/MIT.html
+//
+// This software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied.
+
 const std = @import("std");
 
 const Diagnostics = @import("./parser.zig").Diagnostics;