soml-lang 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1da7419c0865c3f10d59dab2f4e5b8d638b814a11ed322a2885c7d6e3e3aecee
-  data.tar.gz: ed89f8ed61c0c624cf3023ec9f3199b76eec6e7f090992df90409f065e175937
+  metadata.gz: 808fb7da3c2ca5866146bef2193cbf96c4d4e91077c65ada841afd077b1e5282
+  data.tar.gz: 03113f26b03a51156a4c7b30ac2dbde6fda0e908df06f5b11c349c69ef2619d7
 SHA512:
-  metadata.gz: de26c20a01ef8fa144bf98402e2ae7d145f9b1ba22dfbd7b8fa02c283a3e66efbdf0060a9d5718ace01f1240384af0090c19717a802e3563e8c1d9f4534f182a
-  data.tar.gz: 65dce6ea77612c06ab6b5d656f1aa4bd030306c590416013b508797b47dd03ebedd3faa7be0ab9deb83d79d246ebc8b448cd7b1ed4db86f4f39d9e600351009c
+  metadata.gz: 9ede6de7ba3eeea51fa44fe111832a090018d5f5ab589232702b4c0d8cff010f04da9e1a91c52a8a726d77afe2e9b37c14b070631a70bdbece238cc73ece047b
+  data.tar.gz: 2ba19a6d60471afa8d03dc54c0277bf628ee7cd0ba57620a9c5ea0c353805f2843160fa7dc8c1356215cbe12fbfede87b401c2cda355cf90c1c851073d0bd2b4

data/lib/soml/duration.rb

@@ -29,16 +29,14 @@ module SOML
 		# @return [Duration]
 		# @raise [ParseError] When `text` is not a valid duration.
 		# @raise [TypeError] When `text` is not a string.
-		def self.parse(text)
-			Parser.new(text).parse_duration_literal
-		end
+		def self.parse(text) = Parser.new(text).parse_duration_literal
 
-		# Make a duration from a number of seconds, the inverse of {#to_r}. The seconds are rounded to the nearest nanosecond, because a `Float` such as `0.1` is not exact.
+		# Make a duration from a number of seconds, the inverse of {#to_r}. The seconds are rounded to the nearest nanosecond, with ties to even, because a `Float` such as `0.1` is not exact.
 		#
 		# @param seconds [Numeric] An `Integer`, a `Float`, a `Rational`, or another real number.
 		# @return [Duration]
 		# @raise [TypeError] When `seconds` is not a number.
-		# @raise [RangeError] When `seconds` is not finite, not real, or outside the 64-bit range of nanoseconds.
+		# @raise [RangeError] When `seconds` is not finite or not real, or the rounded nanosecond count is outside the 64-bit range.
 		#
 		# @example
 		#   SOML::Duration.from_seconds(90)
@@ -50,7 +48,7 @@ module SOML
 			# `Numeric ===` checks the class itself, so an `ActiveSupport::Duration`, which only claims to be a `Numeric`, must be converted with `to_r` first. Its months are an average length.
 			raise TypeError, "A duration is made from a number of seconds, got #{Parser.describe_argument(seconds)}" unless Numeric === seconds
 
-			new(nanoseconds: (seconds.to_r * 1_000_000_000).round)
+			new(nanoseconds: (seconds.to_r * 1_000_000_000).round(half: :even))
 		end
 
 		# @param nanoseconds [Integer] The length in nanoseconds.
@@ -80,15 +78,11 @@ module SOML
 
 		# @return [Duration] The same length in the other direction.
 		# @raise [RangeError] For the most negative duration, whose opposite is outside the 64-bit range.
-		def -@
-			Duration.new(nanoseconds: -nanoseconds)
-		end
+		def -@ = Duration.new(nanoseconds: -nanoseconds)
 
 		# @return [Duration]
 		# @raise [RangeError] For the most negative duration, whose length is outside the 64-bit range.
-		def abs
-			negative? ? -self : self
-		end
+		def abs = negative? ? -self : self
 
 		# A number has no unit, so only a duration can be added.
 		#
@@ -100,27 +94,19 @@ module SOML
 		# @example
 		#   SOML::Duration.parse('1h') + SOML::Duration.parse('30m')
 		#   #=> #<SOML::Duration 1h30m>
-		def +(other)
-			Duration.new(nanoseconds: nanoseconds + nanoseconds_of(other))
-		end
+		def +(other) = Duration.new(nanoseconds: nanoseconds + nanoseconds_of(other))
 
 		# @param other [Duration]
 		# @return [Duration]
 		# @raise [TypeError] When `other` is not a duration.
 		# @raise [RangeError] When the difference is outside the 64-bit range.
-		def -(other)
-			Duration.new(nanoseconds: nanoseconds - nanoseconds_of(other))
-		end
+		def -(other) = Duration.new(nanoseconds: nanoseconds - nanoseconds_of(other))
 
 		# @return [Rational] The length in seconds, exactly.
-		def to_r
-			Rational(nanoseconds, 1_000_000_000)
-		end
+		def to_r = Rational(nanoseconds, 1_000_000_000)
 
 		# @return [Float] The length in seconds, for `sleep` and `Timeout.timeout`.
-		def to_f
-			nanoseconds.fdiv(1_000_000_000)
-		end
+		def to_f = nanoseconds.fdiv(1_000_000_000)
 
 		# @return [String] The canonical spelling, such as `1h30m`, `1.5s`, or `0s`.
 		def to_s
@@ -128,32 +114,24 @@ module SOML
 			return +'0s' if nanoseconds.zero?
 
 			magnitude = nanoseconds.abs
-			hours, rest = magnitude.divmod(3_600_000_000_000)
-			minutes, rest = rest.divmod(60_000_000_000)
-			seconds, fraction = rest.divmod(1_000_000_000)
+			hours, rest = magnitude.divmod(DURATION_UNITS['h'])
+			minutes, rest = rest.divmod(DURATION_UNITS['m'])
+			seconds, fraction = rest.divmod(DURATION_UNITS['s'])
 			text = nanoseconds.negative? ? +'-' : +''
 			text << "#{hours}h" if hours.positive?
 			text << "#{minutes}m" if minutes.positive?
 
-			if seconds.positive? || fraction.positive?
-				text << seconds.to_s
-				# The fraction is written like an instant's: nine digits with the trailing zeros removed.
-				text << ".#{format('%09d', fraction).sub(/0+\z/, '')}" if fraction.positive?
-				text << 's'
-			end
+			# The fraction is written like an instant's: nine digits with the trailing zeros removed.
+			text << "#{seconds}#{Generator.format_fraction(fraction)}s" if seconds.positive? || fraction.positive?
 
 			text
 		end
 
 		# @return [String]
-		def inspect
-			"#<SOML::Duration #{self}>"
-		end
+		def inspect = "#<SOML::Duration #{self}>"
 
 		# @api private
-		def pretty_print(printer)
-			printer.text(inspect)
-		end
+		def pretty_print(printer) = printer.text(inspect)
 
 		private
 

data/lib/soml/edit.rb

@@ -13,13 +13,20 @@ module SOML
 		private_constant :Removal, :Replacement
 
 		# @param source [String] The document.
-		# @param path [Array<String, Symbol, Integer>]
+		# @param path [Array<String, Symbol, Integer>, Tree::MemberNode, Tree::ObjectNode, Tree::ArrayNode, Tree::ScalarNode]
 		# @param value [Object] The new value, unless `delete` is true.
 		# @param delete [Boolean] Whether to remove the value instead.
 		def initialize(source, path, value, delete:)
+			case path
+			when Tree::MemberNode, Tree::ObjectNode, Tree::ArrayNode, Tree::ScalarNode
+				tree = Tree.new(source, lean: true)
+				path = node_path(tree.body, path)
+				raise ArgumentError, 'The node must be a member or a non-root value from the same source' unless path
+			end
+
 			# `Array#all?` on something else than an array, such as a hash, would read it in another way.
 			unless Array === path && !path.empty? && path.all? { |segment| (Integer === segment && !segment.negative?) || String === segment || Symbol === segment }
-				raise TypeError, 'The path must be a non-empty array of keys and array indexes'
+				raise TypeError, 'The path must be a non-empty array of keys and array indexes, or a member or value node from SOML.parse_tree'
 			end
 
 			# A key is checked as `generate` checks one, and read as the UTF-8 string it names, so that a symbol finds its string. A key of a removal is not written, so a carriage return in it is no error: it finds nothing.
@@ -38,7 +45,7 @@ module SOML
 			@value = value
 			@delete = delete
 
-			tree = Tree.new(source)
+			tree ||= Tree.new(source, lean: true)
 			@source = tree.source
 			# The same bytes, for the searches for a line break from an offset that may be inside a character, such as the last byte of a line that ends with `é`, which `String#byterindex` refuses in UTF-8.
 			@bytes = @source.b
@@ -52,7 +59,7 @@ module SOML
 			# The end of each comment, by its start, so that the trivia between tokens can be skipped.
 			@comment_ends = @comments.to_h { [it.start, it.finish] }
 			# The start of each block comment, by its end, so that the comments before a member or an item can be found.
-			@block_comment_starts = @comments.select { it.type == :block }.to_h { [it.finish, it.start] }
+			@block_comment_starts = @comments.filter_map { [it.finish, it.start] if it.type == :block }.to_h
 		end
 
 		# @return [String] The changed document.
@@ -83,6 +90,25 @@ module SOML
 
 		private
 
+		# Resolve a parsed node to the path that the editor follows, or `nil` when it is not a member or a non-root value of `body`. Matching complete nodes also rejects mismatched spans or values; callers must still use the same source. The search goes down through the one member or item whose span holds the node, so it reads one of them at each level.
+		def node_path(body, target)
+			path = []
+			container = body
+
+			while container.type == :object || container.type == :array
+				is_object = container.type == :object
+				items = is_object ? container.members : container.elements
+				index = items.bsearch_index { it.finish > target.start }
+				item = index && items[index]
+				return if item.nil? || item.start > target.start
+
+				path << (is_object ? item.key.value : index)
+				return path if item == target || (is_object && item.value == target)
+
+				container = is_object ? item.value : item
+			end
+		end
+
 		def edit_in_array(array, index, depth)
 			position = @path[index]
 			raise TypeError, "Cannot edit #{describe_path(@path)}, because #{describe_parent(index)} is an array, so it needs an index, not a key" unless Integer === position
@@ -140,7 +166,7 @@ module SOML
 
 			return if @delete
 
-			written_key = SOML.bare_key?(key) ? key : Generator.new.generate_value(key, 0)
+			written_key = Generator.format_key(key)
 			new_value = nest(index + 1)
 			insert(object, object.members.last) { |indentation| "#{written_key}: #{value_text(new_value, index + 1, depth + 1, indentation, object)}" }
 		end
@@ -192,7 +218,7 @@ module SOML
 			# When the removed item is the last one and has no comma after it, it takes the comma before it, so that no trailing comma is left, as `[1, 2]` becomes `[1]`.
 			takes_comma_before = node.equal?(items.last) && @source.getbyte(skip_trivia(node.finish)) != 0x2C
 			removal = node_removal(node, takes_comma_before)
-			take_blank_line(removal, container, content_start(container)) if removal.is_whole_lines
+			take_blank_line(removal, container) if removal.is_whole_lines
 
 			if items.length == 1 && braced?(container) && !comment_left?(container, removal)
 				@replacements << Replacement.new(container.start + 1, container.finish - 1, '')
@@ -267,21 +293,22 @@ module SOML
 			Removal.new(is_last ? skip_spaces_back(start) : start, after, false)
 		end
 
-		# Widens a removal of whole lines by a blank line that would otherwise be left next to another blank line, or directly inside a bracket. `content_start` is the container's, from `content_start`.
-		def take_blank_line(removal, container, content_start)
+		# Widens a removal of whole lines by a blank line that would otherwise be left next to another blank line, or directly inside a bracket.
+		def take_blank_line(removal, container)
 			is_blank_before = removal.start.positive? && blank_line?(line_start(removal.start - 1))
 			is_blank_after = removal.finish < @length && blank_line?(removal.finish)
 
 			if is_blank_before && (is_blank_after || at_closing?(removal.finish, container))
 				removal.start = line_start(removal.start - 1)
-			elsif is_blank_after && removal.start == content_start
-				removal.finish = @bytes.byteindex("\n", removal.finish) + 1
+			elsif is_blank_after && removal.start == content_start(container)
+				# The line is blank, so its line break follows its spaces.
+				removal.finish = skip_spaces(removal.finish) + 1
 			end
 		end
 
 		# The offset after the blank lines that start at `offset`.
 		def skip_blank_lines(offset)
-			offset = @bytes.byteindex("\n", offset) + 1 while offset < @length && blank_line?(offset)
+			offset = skip_spaces(offset) + 1 while blank_line?(offset)
 			offset
 		end
 
@@ -299,9 +326,7 @@ module SOML
 			line_end && skip_blank_lines(line_end + 1)
 		end
 
-		def blank_line?(line_start)
-			@source.getbyte(skip_spaces(line_start)) == 0x0A
-		end
+		def blank_line?(line_start) = @source.getbyte(skip_spaces(line_start)) == 0x0A
 
 		def line_start(offset)
 			return 0 if offset.zero?
@@ -435,13 +460,9 @@ module SOML
 			offset
 		end
 
-		def space?(byte)
-			byte == 0x20 || byte == 0x09
-		end
+		def space?(byte) = byte == 0x20 || byte == 0x09
 
-		def braced?(container)
-			container.type == :array || container.braced
-		end
+		def braced?(container) = container.type == :array || container.braced
 
 		# `@value` inside new objects for the keys of the path from `index` on. An index there names an item of an array that does not exist yet, so it raises an `IndexError`.
 		def nest(index)
@@ -461,8 +482,6 @@ module SOML
 		def describe_path(path) = Parser.describe_path(path)
 
 		# The value that holds `@path[index]`.
-		def describe_parent(index)
-			index.zero? ? 'the document' : describe_path(@path.first(index))
-		end
+		def describe_parent(index) = index.zero? ? 'the document' : describe_path(@path.first(index))
 	end
 end

data/lib/soml/error.rb

@@ -2,7 +2,19 @@
 
 module SOML
 	# The base class of the errors this library raises.
-	class Error < StandardError; end
+	class Error < StandardError
+		# Characters that a terminal acts on rather than shows: control characters other than tab, and bidirectional controls. They are replaced in an error message, so that printing it cannot run a terminal escape or reorder the text.
+		UNPRINTABLE = /[\p{Bidi_Control}[\p{Cc}&&[^\t]]]/
+
+		private_constant :UNPRINTABLE
+
+		# `text` with the characters that a terminal acts on replaced, for every message that can show a value or a name from the caller.
+		#
+		# @api private
+		# @param text [String]
+		# @return [String]
+		def self.sanitize(text) = text.gsub(UNPRINTABLE, "\uFFFD")
+	end
 
 	# Raised by {SOML.parse}, {SOML.load_file}, and {SOML::Duration.parse} when the input is not valid.
 	#
@@ -21,10 +33,7 @@ module SOML
 		CONTEXT_LINES = 2
 		MAX_LINE_WIDTH = 100
 
-		# Characters that a terminal acts on rather than shows: control characters other than tab, and bidirectional controls. They are replaced in an error message, so that printing it cannot run a terminal escape or reorder the text.
-		UNPRINTABLE = /[\p{Bidi_Control}[\p{Cc}&&[^\t]]]/
-
-		private_constant :CONTEXT_LINES, :MAX_LINE_WIDTH, :UNPRINTABLE
+		private_constant :CONTEXT_LINES, :MAX_LINE_WIDTH
 
 		# @return [String] What is wrong, without the position.
 		attr_reader :reason
@@ -47,7 +56,7 @@ module SOML
 		# @param byte_offset [Integer] Where the error is in `source`, in bytes.
 		# @param path [String, nil] The file the source is from.
 		def initialize(reason, source, byte_offset, path = nil)
-			@reason = sanitize(reason)
+			@reason = Error.sanitize(reason)
 
 			# A copy, which shares the bytes, so that a caller that changes its string afterwards does not change the code frame.
 			@source = source.dup
@@ -75,9 +84,7 @@ module SOML
 		# The message and the code frame, which Ruby shows for an uncaught error.
 		#
 		# @return [String]
-		def detailed_message(highlight: false, **)
-			"#{super}\n\n#{code_frame}"
-		end
+		def detailed_message(highlight: false, **) = "#{super}\n\n#{code_frame}"
 
 		private
 
@@ -95,11 +102,10 @@ module SOML
 			gutter_width = @line.to_s.length
 			output = []
 
-			line_starts.each_with_index do |line_start, index|
-				number = first_line + index
+			line_starts.each.with_index(first_line) do |line_start, number|
 				is_error_line = number == @line
 				line_end = @source.index("\n", line_start) || @source.length
-				text, pointer = clip(sanitize(@source[line_start...line_end]), is_error_line ? @offset - line_start : 0)
+				text, pointer = clip(Error.sanitize(@source[line_start...line_end]), is_error_line ? @offset - line_start : 0)
 				gutter = "#{is_error_line ? '>' : ' '} #{number.to_s.rjust(gutter_width)} |"
 				output << (text.empty? ? gutter : "#{gutter} #{text}")
 
@@ -124,13 +130,9 @@ module SOML
 			["#{prefix}#{text[start...finish]}#{suffix}", pointer - start + prefix.length]
 		end
 
-		def sanitize(text)
-			text.gsub(UNPRINTABLE, "\uFFFD")
-		end
-
 		# The path in UTF-8, so that it joins the reason, with what is not printable replaced, as in the reason.
 		def show_path(path)
-			sanitize(Parser.lossy_utf8(path))
+			Error.sanitize(Parser.lossy_utf8(path))
 		end
 	end
 
@@ -158,7 +160,15 @@ module SOML
 		# @api private
 		def initialize(reason)
 			@path = []
+
+			# The reason may name a class or show a value, as in `Cannot generate a Foo`, which can hold anything, so it is sanitized as the reason of a `ParseError` is.
+			super(Error.sanitize(reason))
+		end
+
+		# A copy, as made by `raise error, 'Other'`, has its own path, so that adding to the path of one does not change the other.
+		def initialize_copy(other)
 			super
+			@path = @path.dup
 		end
 
 		# @return [String] The reason, and the path to the value when it is not the top-level value.

data/lib/soml/format.rb

@@ -5,6 +5,11 @@ module SOML
 	#
 	# @api private
 	class Printer
+		# The brackets of a container, by its type, so that writing one allocates no array for them.
+		BRACKETS = Ractor.make_shareable({object: ['{', '}'], array: ['[', ']']})
+
+		private_constant :BRACKETS
+
 		# @param tree [Tree]
 		def initialize(tree)
 			@source = tree.source
@@ -27,6 +32,7 @@ module SOML
 
 		# Starts a new line at `level`, with one blank line before it when the source had one.
 		def new_line(level, is_blank)
+			# The first line of the file has no line break before it.
 			return if @output.empty?
 
 			@output << (is_blank ? "\n\n" : "\n") << INDENTS[level]
@@ -100,6 +106,7 @@ module SOML
 
 			# Between two items there is only whitespace, comments, and at most one comma.
 			while index < finish
+				# A comma inside a comment is not one. Each jump lands on the line feed after a line comment, or on the `/` of a block comment's end, and the loop steps past it.
 				case source.getbyte(index)
 				when 0x2C # ,
 					return index
@@ -123,11 +130,12 @@ module SOML
 			item_end = nil
 			# Whether a comment may stay at the end of the line before it, which needs an item or an opening bracket there.
 			can_trail = is_bracketed
+			# Whether the list has written something other than a comment at the end of the opening bracket's line. A blank line is kept only after that, so none is left directly inside the bracket or at the start of the file.
 			has_written = false
 			is_on_same_line = false
 
 			# One more round than there are items, for the comments after the last one.
-			(0..items.length).each do |index|
+			0.upto(items.length) do |index|
 				item = items[index]
 				item_start = item ? item.start : finish
 				comma = is_bracketed ? find_comma(previous_end, item_start) : nil
@@ -176,7 +184,7 @@ module SOML
 			previous_end = start + 1
 			has_written_token = false
 
-			(0..items.length).each do |index|
+			0.upto(items.length) do |index|
 				item = items[index]
 				item_start = item ? item.start : finish - 1
 				# The comma after the last item is left out.
@@ -290,8 +298,10 @@ module SOML
 				return
 			end
 
-			opening, closing, items = node.type == :object ? ['{', '}', node.members] : ['[', ']', node.elements]
+			opening, closing = BRACKETS[node.type]
+			items = node.type == :object ? node.members : node.elements
 
+			# Every comment before the container is already written, so a next comment that ends by `finish` is inside it. A container that holds only comments is not empty.
 			if items.empty? && peek_comment(finish).nil?
 				@output << opening << closing
 				return
@@ -311,6 +321,8 @@ module SOML
 		# Only spaces and tabs are whitespace in SOML. Any other character, such as a no-break space, is content.
 		def trim_trailing_whitespace(text)
 			# A loop rather than a regex, which would keep a backtracking entry for every space of a long run.
+			#
+			# Note: Not using `rstrip(" \t")` because it is slower for typical short lines.
 			finish = text.bytesize
 			finish -= 1 while finish.positive? && ((byte = text.getbyte(finish - 1)) == 0x20 || byte == 0x09)
 			text.byteslice(0, finish)
@@ -320,10 +332,11 @@ module SOML
 		def reindent_block_string(text, indentation)
 			lines = text.split("\n", -1)
 			closing = lines.last
+			# Note: Not using `lstrip(" \t")` because it allocates a string and is slower than this scan.
 			old_length = 0
 			old_length += 1 while (byte = closing.getbyte(old_length)) == 0x20 || byte == 0x09
 
-			lines.each_with_index.map do |line, index|
+			lines.map.with_index do |line, index|
 				index.zero? || !line.match?(NOT_BLANK_CHARACTER) ? line : indentation + line.byteslice(old_length, line.bytesize - old_length)
 			end.join("\n")
 		end

data/lib/soml/generator.rb

@@ -6,6 +6,8 @@ module SOML
 	# @api private
 	class Generator
 		# A byte that cannot be in a `'...'` string: a control character, an apostrophe, or DEL. A string with one is written as `"..."`. The set is a byte table, because a scan of it is faster than the regex it replaces.
+		#
+		# Note: Not using `String#count` because it is slower for typical short strings.
 		NEEDS_ESCAPED_BYTE = Array.new(256) { |byte| byte < 0x20 || byte == 0x27 || byte == 0x7F }.freeze
 
 		ESCAPED_CHARACTER = /[\x00-\x1F"\\\x7F]/
@@ -22,6 +24,20 @@ module SOML
 
 		private_constant :NEEDS_ESCAPED_BYTE, :ESCAPED_CHARACTER, :ESCAPES
 
+		# A key as a document writes it, bare when it can be, for {Parser} to suggest a key and for {Editor} to write a new member.
+		#
+		# @param key [String] A key that {#member_name} checked.
+		# @return [String]
+		def self.format_key(key) = SOML.bare_key?(key) ? key : new.generate_value(key, 0)
+
+		# The fraction of a second of an instant or a duration as a document writes it: a point and nine digits with the trailing zeros removed, or nothing when there is none.
+		#
+		# Note: Not using `sprintf` because its padding is slower than `to_s.rjust`.
+		#
+		# @param nanoseconds [Integer] The fraction, below one second.
+		# @return [String]
+		def self.format_fraction(nanoseconds) = nanoseconds.zero? ? '' : ".#{nanoseconds.to_s.rjust(9, '0').rstrip('0')}"
+
 		# @param canonical [Boolean] Whether members are sorted by key, as in canonical form, rather than kept in the order of their hash.
 		# @param one_line [Boolean] Whether a container is written on one line, as in `[1, {a: 2}]`, for {Editor} to write a value inside a container that is on one line.
 		def initialize(canonical: false, one_line: false)
@@ -111,6 +127,11 @@ module SOML
 				write_string(value.name)
 			when Time
 				@buffer << format_instant(value)
+			# `DateTime` is a subclass of `Date`, so it must come first.
+			when DateTime
+				raise GenerateError, 'Cannot generate a DateTime. Convert it to a Time with to_time'
+			when Date
+				@buffer << format_date(value)
 			when Duration
 				@buffer << value.to_s
 			else
@@ -130,7 +151,7 @@ module SOML
 			enter(value, depth)
 			inner_indent = INDENTS[indent.length + 1]
 
-			if value.is_a?(Array)
+			if Array === value
 				write_array(value, depth, indent, inner_indent)
 			else
 				write_hash(value, depth, indent, inner_indent)
@@ -145,6 +166,7 @@ module SOML
 			@buffer << '[' << @line_break
 			index = 0
 
+			# Note: Not using `each_index` because its block overhead slows this hot loop under YJIT.
 			while index < array.length
 				@buffer << item_prefix(index, inner_indent)
 
@@ -198,6 +220,7 @@ module SOML
 
 		# Yields each member with its key as a UTF-8 string, in the order of the hash, or sorted by key for canonical form.
 		def each_member(hash)
+			# Note: Not using a `hash.each_key` enumerator because it is slower than iterating the key array.
 			keys = hash.keys
 			sort_keys!(keys) if @canonical
 			names = {}
@@ -216,29 +239,28 @@ module SOML
 		# Sorts the keys by their UTF-8 names. UTF-8 byte order is code point order, which is the canonical order.
 		def sort_keys!(keys)
 			# The common cases, all keys strings or all symbols in UTF-8 or US-ASCII, sort the keys themselves, because then their byte order is the order of their UTF-8 names. A string from `Symbol#to_s` is in US-ASCII. Anything else, such as a symbol in ISO-8859-1, sorts the keys by their UTF-8 names.
-			if keys.all? { |key| String === key && utf8_compatible?(key) } || keys.all? { |key| Symbol === key && utf8_compatible?(key) }
+			if keys.all? { String === it && utf8_compatible?(it) } || keys.all? { Symbol === it && utf8_compatible?(it) }
 				keys.sort!
 			else
-				keys.replace(keys.map { |key| [member_name(key), key] }.sort_by!(&:first).map!(&:last))
+				keys.sort_by! { member_name(it) }
 			end
 		end
 
-		def utf8_compatible?(key)
-			key.encoding == Encoding::UTF_8 || key.encoding == Encoding::US_ASCII
-		end
+		def utf8_compatible?(key) = key.encoding == Encoding::UTF_8 || key.encoding == Encoding::US_ASCII
 
 		# A key that `member_name` checked, so it is valid UTF-8 without a carriage return.
 		def write_key(key)
 			if SOML.bare_key?(key)
 				@buffer << key
 			else
-				write_string(key)
+				write_quoted(key)
 			end
 		end
 
-		def write_string(string)
-			string = to_utf8(string, 'string')
+		def write_string(string) = write_quoted(to_utf8(string, 'string'))
 
+		# Writes a valid UTF-8 string between quotes, as a `'...'` string when it can be one.
+		def write_quoted(string)
 			# One scan settles the common case: no quote and no control character.
 			index = 0
 			length = string.bytesize
@@ -248,6 +270,7 @@ module SOML
 			end
 
 			if index == length
+				# Note: Not using `append_as_bytes` because it is slower for typical short strings in the full generator.
 				@buffer << "'" << string << "'"
 				return
 			end
@@ -291,7 +314,7 @@ module SOML
 
 			mantissa, exponent = text.delete_prefix('-').split('e')
 			whole, fraction = mantissa.split('.')
-			digits = "#{whole}#{fraction}".sub(/0+\z/, '')
+			digits = "#{whole}#{fraction}".rstrip('0')
 			length = digits.length
 
 			# The decimal point is after `point` digits, so the value is 0.digits × 10^point.
@@ -311,41 +334,48 @@ module SOML
 			value.negative? ? "-#{body}" : body
 		end
 
+		# Use the native components, even for a subclass that overrides them, and without converting through an instant or another calendar.
+		def format_date(date)
+			text = Date.instance_method(:iso8601).bind_call(date)
+			year = Date.instance_method(:year).bind_call(date)
+			raise GenerateError, "Cannot generate the date #{text}, because it is outside the years 0001 to 9999" unless year.between?(1, 9999)
+			raise GenerateError, "Cannot generate the Julian date #{text}. Convert it to a Gregorian Date with new_start(Date::GREGORIAN), which must be in the years 0001 to 9999" unless Date.instance_method(:gregorian?).bind_call(date)
+
+			text
+		end
+
 		def format_instant(time)
-			utc = time.getutc
+			# `getutc` makes a copy, which a time in UTC, as `SOML.parse` returns it, does not need.
+			utc = time.utc? ? time : time.getutc
 			nanoseconds = utc.nsec
 
-			# A time made from a float, such as `Time.at(Time.now.to_f)`, has the float's binary fraction.
-			raise GenerateError, "Cannot generate the instant #{time.inspect}, because it has a fraction of a second finer than a nanosecond. Round it to nanoseconds with time.round(9)" unless utc.subsec * 1_000_000_000 == nanoseconds
-			raise GenerateError, "Cannot generate the instant #{time.inspect}, because in UTC it falls outside the years 0001 to 9999" unless utc.year.between?(1, 9999)
-
-			text = format('%04d-%02d-%02dT%02d:%02d:%02d', utc.year, utc.month, utc.day, utc.hour, utc.min, utc.sec)
+			# A time made from a float, such as `Time.at(Time.now.to_f)`, has the float's binary fraction. A subclass of `Time` may define its own `inspect`.
+			raise GenerateError, "Cannot generate the instant #{Time.instance_method(:inspect).bind_call(time)}, because it has a fraction of a second finer than a nanosecond. Round it to nanoseconds with time.round(9)" unless (1_000_000_000 % utc.subsec.denominator).zero?
+			raise GenerateError, "Cannot generate the instant #{Time.instance_method(:inspect).bind_call(time)}, because in UTC it falls outside the years 0001 to 9999" unless utc.year.between?(1, 9999)
 
-			# The fraction is nine digits with the trailing zeros removed.
-			text << ".#{format('%09d', nanoseconds).sub(/0+\z/, '')}" if nanoseconds.positive?
-			text << 'Z'
+			# The year is 0001 to 9999, so `xmlschema` writes four digits, and a time in UTC ends with `Z`.
+			#
+			# Note: Not using `strftime` because Ruby 4's core `xmlschema` is faster.
+			text = utc.xmlschema
+			nanoseconds.zero? ? text : "#{text.chop}#{Generator.format_fraction(nanoseconds)}Z"
 		end
 
-		# The class is read with `Kernel#class`, which a `BasicObject` does not have. An anonymous class, such as one from `Data.define`, is named by its nearest named superclass.
+		# An anonymous class, such as one from `Data.define`, is named by its nearest named superclass.
 		def describe(value)
 			case value
 			when nil, true, false
 				value.inspect
 			else
-				type = Kernel.instance_method(:class).bind_call(value)
+				type = Parser.class_of(value)
 				named = type
-				named = named.superclass until named.name
-				name = Parser.lossy_utf8(named.equal?(type) ? type.name : "anonymous #{named.name}")
+				named = named.superclass until (name = Parser.module_name(named))
+				name = Parser.lossy_utf8(named.equal?(type) ? name : "anonymous #{name}")
 				"#{name.match?(/\A[AEIOUaeiou]/) ? 'an' : 'a'} #{name}"
 			end
 		end
 
 		def describe_unsupported(value)
-			if defined?(::DateTime) && ::DateTime === value
-				'Cannot generate a DateTime. Convert it to a Time with to_time'
-			elsif defined?(::Date) && ::Date === value
-				"Cannot generate a Date, because a date is not an instant. Write it as a String, such as '#{value}'"
-			elsif defined?(::ActiveSupport::Duration) && ::ActiveSupport::Duration === value
+			if defined?(::ActiveSupport::Duration) && ::ActiveSupport::Duration === value
 				# Rails code writes `5.minutes`. Its days, months, and years follow the calendar, so it is not converted.
 				"Cannot generate an ActiveSupport::Duration, because its days, months, and years are not a fixed length. Use a SOML::Duration, such as SOML::Duration.parse('5m')"
 			elsif Numeric === value
@@ -357,7 +387,7 @@ module SOML
 			elsif Pathname === value
 				"Cannot generate #{describe(value)}. Convert it to a String with to_s"
 			else
-				"Cannot generate #{describe(value)}. Only Hash, Array, String, Symbol, Integer, Float, true, false, nil, Time, and SOML::Duration can be generated"
+				"Cannot generate #{describe(value)}. Only Hash, Array, String, Symbol, Integer, Float, true, false, nil, Date, Time, and SOML::Duration can be generated"
 			end
 		end
 	end