predicator 1.2.1 → 2.0.0

data/lib/predicator/iso_text.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Predicator
+  # ISO 8601 text read as the `::date` and `::datetime` casts read it: the
+  # forms the reference's host parser accepts, which the reference hands such
+  # text to.
+  #
+  # A date is four digits of year, optionally signed (the sign the year's),
+  # a month and a day, naming a real calendar date. A datetime is such a
+  # date, `T` or a space, hours, minutes and seconds of a time a day has, an
+  # optional fraction after a full stop or a comma (read to the microsecond,
+  # further digits dropped), and an offset: `Z`, or a sign with two digits of
+  # hours and optionally two of minutes, with or without a colon, of at most
+  # 23 hours and 59 minutes. The text `-00:00` is refused, as the reference
+  # refuses it, while `-0000` and `-00` read as UTC. The offset is applied:
+  # the answer is the instant the text names, in UTC, and an instant whose
+  # year in UTC falls outside {YEARS} is refused (the reference raises
+  # there).
+  #
+  # Each field of the offset is two digits. The reference's ISA (docs/isa.md,
+  # section 5) asks `::datetime` for an ISO 8601 datetime with a UTC offset,
+  # and an ISO 8601 offset's hour and minute fields are digits with no sign
+  # of their own, so a text such as `+-5:30` is refused here. The
+  # reference's host parser reads each field as an integer that may carry a
+  # sign and answers an instant for it.
+  #
+  # The module holds no state. It is private to the package.
+  module IsoText
+    DATE_TEXT = /\A([+-]?)([0-9]{4})-([0-9]{2})-([0-9]{2})\z/
+    DATETIME_TEXT = /\A([+-]?)([0-9]{4})-([0-9]{2})-([0-9]{2})[T ]([0-9]{2}):([0-9]{2}):([0-9]{2})
+                     (?:[.,]([0-9]+))?(Z|[+-][0-9]{2}(?::?[0-9]{2})?)\z/x
+    OFFSET_TEXT = /\A([+-])([0-9]{2}):?([0-9]{2})?\z/
+
+    # The years an instant may fall in, in UTC.
+    YEARS = (-9999..9999)
+
+    module_function
+
+    # @param text [String]
+    # @return [Date, nil] the date the text names, or nil
+    def read_date(text)
+      match = DATE_TEXT.match(text)
+      civil_date(*match.captures) if match
+    end
+
+    # @param text [String]
+    # @return [DateTime, nil] the instant the text names, or nil
+    def read_datetime(text)
+      instant = read_instant(text)
+      in_years(instant) if instant
+    end
+
+    # The instant the text names, whatever its year in UTC: a datetime
+    # literal in source reads its text so, as the reference's literal does.
+    #
+    # @param text [String]
+    # @return [DateTime, nil] the instant the text names, or nil
+    def read_instant(text)
+      match = DATETIME_TEXT.match(text)
+      return unless match
+
+      sign, year, month, day, *clock, fraction, zone = match.captures
+      local = local_instant(civil_date(sign, year, month, day), clock.map { |part| Integer(part, 10) }, fraction)
+      offset = read_offset(zone)
+      local.with(epoch_seconds: local.epoch_seconds - offset) if local && offset
+    end
+
+    def civil_date(sign, *parts)
+      year, month, day = parts.map { |part| Integer(part, 10) }
+      year = -year if sign == "-"
+      Date.new(year:, month:, day:) if Civil.civil?(year, month, day)
+    end
+
+    def local_instant(date, (hour, minute, second), fraction)
+      return unless date && hour <= 23 && minute <= 59 && second <= 59
+
+      microsecond = Integer("#{fraction}000000"[0, 6], 10)
+      Civil.instant_at(date, hour, minute, second, microsecond:)
+    end
+
+    def in_years(instant) = (instant if YEARS.cover?(Civil.date_of(instant).year))
+
+    # The seconds the offset stands east of UTC, or nil when the reference
+    # refuses it.
+    def read_offset(zone)
+      return 0 if zone == "Z"
+      return if zone == "-00:00"
+
+      sign, hours, minutes = OFFSET_TEXT.match(zone).captures
+      hours = Integer(hours, 10)
+      minutes = Integer(minutes || "0", 10)
+      return if hours > 23 || minutes > 59
+
+      seconds = (hours * 3600) + (minutes * 60)
+      sign == "-" ? -seconds : seconds
+    end
+  end
+  private_constant :IsoText
+end

data/lib/predicator/lexer/literals.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Predicator
+  module Lexer
+    # The string and date literals, read into the scan that includes this
+    # module (its scanner, its running line and column, its tokens).
+    module Literals
+      # The escapes a string literal decodes. Any other escaped character
+      # stands for itself, so an unrecognized escape loses its backslash.
+      ESCAPES = { "n" => "\n", "t" => "\t", "r" => "\r" }.freeze
+
+      # A literal's run of characters that neither close it nor escape, by
+      # its quote.
+      PLAIN = { '"' => /[^"\\]*/, "'" => /[^'\\]*/ }.freeze
+
+      # The quote a string token carries, by its character.
+      QUOTES = { '"' => :double, "'" => :single }.freeze
+
+      # The refusal of the numeric escape, in either spelling of its letter.
+      NUMERIC_ESCAPE = "Unsupported escape sequence \\u in string literal: predicator has no numeric " \
+                       "escape; write the character itself (string literals are UTF-8)"
+
+      private
+
+      # A string literal, quoted with `"` or `'`. A raw line feed inside it
+      # is content and moves the line; a two-character escape advances the
+      # column by two whatever it decodes to, a backslash before a line feed
+      # included. A refusal inside the literal spans its opening quote.
+      def string
+        start = @scanner.pos
+        quote = @scanner.getch
+        content = read_string(quote)
+        return content if content.is_a?(Refusal)
+
+        text = @scanner.string.byteslice(start...@scanner.pos)
+        end_line, end_column = after(text.gsub(/\\./m, ".."), @line, @column)
+        emit(:string, content, text.length, quote: QUOTES.fetch(quote),
+                                            end_position: Position.new(line: end_line, column: end_column))
+        move(end_line, end_column)
+      end
+
+      # The literal's content, up to and past its closing quote; or the
+      # refusal.
+      def read_string(quote)
+        content = +""
+        loop do
+          content << @scanner.scan(PLAIN.fetch(quote))
+          char = @scanner.getch
+          return content if char == quote
+
+          piece = char ? escape(quote) : unterminated(quote)
+          return piece if piece.is_a?(Refusal)
+
+          content << piece
+        end
+      end
+
+      # What the escape after a backslash stands for, or the refusal.
+      def escape(quote)
+        escaped = @scanner.getch
+        return unterminated(quote) if escaped.nil?
+        return refuse("unsupported_escape", NUMERIC_ESCAPE, @line, @column + 1) if %w[u U].include?(escaped)
+
+        ESCAPES.fetch(escaped, escaped)
+      end
+
+      def unterminated(quote)
+        refuse("unterminated_string", "Unterminated #{quote == '"' ? "double" : "single"}-quoted string literal",
+               @line, @column + 1)
+      end
+
+      # A date or datetime literal, `#...#`. A body holding a `T` is read as
+      # a datetime and any other as a date, as {IsoText} reads them (the
+      # datetime unbounded in its year, as the reference's literal is). A
+      # refusal spans the whole literal: through the closing `#`, or through
+      # the end of the source when there is none.
+      def date
+        @scanner.getch
+        body = @scanner.scan(/[^#]*/)
+        end_line, end_column = after(body, @line, @column + 1)
+        return refuse("unterminated_date", "Unterminated date literal", end_line, end_column) unless @scanner.getch
+
+        type, value = read_date(body)
+        return refuse("invalid_#{type}", "Invalid #{type} format: #{body}", end_line, end_column + 1) if value.nil?
+
+        emit(type, value, body.length + 2)
+        move(end_line, end_column + 1)
+      end
+
+      # Moves the running position past a literal that may span lines.
+      def move(line, column)
+        @line = line
+        @column = column
+        nil
+      end
+
+      def read_date(body)
+        return [:datetime, IsoText.read_instant(body)] if body.include?("T")
+
+        [:date, IsoText.read_date(body)]
+      end
+
+      # The line and column just past text that starts at the line and
+      # column given: a line feed starts the next line, and every other
+      # character, a carriage return included, advances the column by one.
+      def after(text, line, column)
+        breaks = text.count("\n")
+        return [line, column + text.length] if breaks.zero?
+
+        [line + breaks, text.length - text.rindex("\n")]
+      end
+    end
+    private_constant :Literals
+  end
+end

data/lib/predicator/lexer/numbers.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Predicator
+  module Lexer
+    # Numbers and the duration units written after them, read into the scan
+    # that includes this module.
+    #
+    # A number is decimal digits with at most one decimal point, which a
+    # digit must follow: `1.` is the number 1 and then a dot. There is no
+    # sign and no exponent. A number followed by a duration unit is an
+    # integer token, or a fractional number token where it has a point, then
+    # one token per unit; a number followed by anything else is an integer
+    # or a float token, so `1.5x` is a float and then an identifier.
+    #
+    # The units are read one after another, the two-letter spellings (`ms`,
+    # `mo`) before the one-letter ones, and the read stops at the first
+    # character that is not a unit: `5days` is 5, the unit `d`, and the
+    # identifier `ays`.
+    #
+    # After the FIRST unit the reference's lexer goes on from a copy of the
+    # text that starts just after that unit and ends at the first line feed
+    # past the copy's first character. Any further units are read inside
+    # that copy, and the source from that line feed on is not read. The
+    # column advances by the grapheme clusters, not the characters, between
+    # the end of the number and the start of what the copy holds after the
+    # units, the dropped text included. Both are reproduced here, the corpus
+    # fixing neither: `5d x`, a line feed and `y` scans as 5, `d` and `x` at
+    # column 6, then the end of input; `5dh`, a line feed and `x` scans as
+    # 5, `d`, `h` and the end of input at column 6 of line 1.
+    module Numbers
+      # The units a duration names, the two-letter spellings first.
+      UNIT = /m[so]|[ydhmsw]/
+
+      private
+
+      # A decimal too large for a finite Float reads as an infinite one, and
+      # is read without asking the host for it ({FloatText.read}): the
+      # reference's lexer raises there, and the emitter refuses the literal.
+      def number
+        text = @scanner.scan(/[0-9]+(?:\.[0-9]+)?/)
+        whole, fraction = text.split(".")
+        unless @scanner.match?(UNIT)
+          value = fraction ? FloatText.read(text) || Float::INFINITY : Integer(whole, 10)
+          return emit(fraction ? :float : :integer, value, text.length)
+        end
+
+        leading = fraction ? Fraction.new(whole: Integer(whole, 10), fraction:) : Integer(whole, 10)
+        emit(fraction ? :fractional_number : :integer, leading, text.length)
+        units
+      end
+
+      def units
+        text = +""
+        dropped = nil
+        while (unit = @scanner.scan(UNIT))
+          @tokens << Token.new(type: :duration_unit, line: @line, column: @column + text.length,
+                               length: unit.length, value: unit)
+          text << unit
+          dropped ||= keep_line
+        end
+        @column += consumed(text, dropped)
+        nil
+      end
+
+      # After the first unit: goes on scanning over the text from here to the
+      # first line feed past its first character alone, and answers the text
+      # dropped after it ("" when the kept text runs to the end of the source).
+      def keep_line
+        line = @scanner.check(/.[^\n]*/m) || ""
+        return "" if @scanner.pos + line.bytesize == @scanner.string.bytesize
+
+        dropped = @scanner.string.byteslice((@scanner.pos + line.bytesize)..)
+        @scanner = StringScanner.new(line)
+        @chain_end = 0
+        dropped
+      end
+
+      # The grapheme clusters the units and the dropped text spanned, as the
+      # reference counts them. The units are ASCII letters, so only the
+      # cluster just after them can join the last; a carriage return ending
+      # the kept text joins the dropped line feed.
+      def consumed(unit_text, dropped)
+        count = "#{unit_text}#{@scanner.check(/\X/)}".scan(/\X/).size - (@scanner.eos? ? 0 : 1)
+        return count if dropped.empty?
+
+        count + dropped.scan(/\X/).size - (!@scanner.eos? && @scanner.string.end_with?("\r") ? 1 : 0)
+      end
+    end
+    private_constant :Numbers
+  end
+end

data/lib/predicator/lexer.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "values"
+require_relative "errors"
+require_relative "iso_text"
+require_relative "float_text"
+require_relative "lexer/literals"
+require_relative "lexer/numbers"
+
+module Predicator
+  # The compiler's scanner: source text in, a token stream out, or the one
+  # refusal that stopped it. It reads the source with a StringScanner and
+  # answers the tokens the reference's lexer answers, at the positions it
+  # gives them; there is no partial stream and no recovery.
+  #
+  # A position counts lines and columns from 1, and a column counts
+  # characters (Unicode codepoints, as the reference counts them), never
+  # bytes. A space and a tab advance the column by one, a line feed starts
+  # the next line, and a carriage return outside a literal advances nothing.
+  # One count is the reference's own and not a column: the stretch a run of
+  # duration units consumes is counted in grapheme clusters ({Numbers}).
+  #
+  # The source is a String in UTF-8 whose encoding is valid. The module holds
+  # no state; each call scans with its own {Scan}. It is private to the
+  # package.
+  module Lexer
+    # One token. The type is one of the reference's token names, as a
+    # Symbol; the length counts the characters of source the token covers.
+    # A string token also carries its quote (`:double` or `:single`) and
+    # the exclusive end of the literal, which is on a later line than its
+    # start when the literal holds a raw line feed. Every other token
+    # carries neither.
+    #
+    # @!attribute [r] value
+    #   @return [Object] what the token stands for: an identifier's or a
+    #     word's text, an Integer, a Float, a {Fraction}, a String's
+    #     content, true or false, {Predicator::UNDEFINED}, nil, a
+    #     {Predicator::Date}, a {Predicator::DateTime}, a unit's or an
+    #     operator's text; nil for the end of input
+    Token = Data.define(:type, :line, :column, :length, :value, :quote, :end_position) do
+      def initialize(type:, line:, column:, length:, value: nil, quote: nil, end_position: nil) = super
+    end
+
+    # The whole number and the fraction digits of a decimal number written
+    # before a duration unit (`0.5h`). The fraction stays the digits written,
+    # so a duration is expanded from exact digits rather than from a Float.
+    Fraction = Data.define(:whole, :fraction)
+
+    # The extent of a refusal: from its start, inclusive, to its end,
+    # exclusive, each a {Predicator::Position}.
+    Span = Data.define(:start, :end)
+
+    # Why the source does not scan: a {Predicator::ParseError} (whose
+    # position is the span's start) and its {Span}.
+    Refusal = Data.define(:error, :span)
+
+    # The words that are not identifiers, by their exact spelling, and the
+    # token type and value each one becomes.
+    RESERVED = {
+      "true" => [:boolean, true], "false" => [:boolean, false],
+      "undefined" => [:undefined, UNDEFINED], "null" => [:null, nil],
+      "AND" => [:and_op, "AND"], "OR" => [:or_op, "OR"], "NOT" => [:not_op, "NOT"],
+      "and" => [:and_op, "and"], "or" => [:or_op, "or"], "not" => [:not_op, "not"],
+      "IN" => [:in_op, "IN"], "in" => [:in_op, "in"],
+      "CONTAINS" => [:contains_op, "CONTAINS"], "contains" => [:contains_op, "contains"],
+      "if" => [:if_kw, "if"], "else" => [:else_kw, "else"], "while" => [:while_kw, "while"],
+      "ago" => [:ago_op, "ago"], "from" => [:from_op, "from"], "now" => [:now_op, "now"],
+      "next" => [:next_op, "next"], "last" => [:last_op, "last"]
+    }.freeze
+
+    # The punctuation, by spelling. A single `&` or `|` is not a token.
+    OPERATORS = {
+      "===" => :strict_equal, "!==" => :strict_ne, ">=" => :gte, "<=" => :lte, "==" => :equal_equal,
+      "!=" => :ne, "&&" => :and_and, "||" => :or_or, "::" => :double_colon, ">" => :gt, "<" => :lt,
+      "=" => :eq, "!" => :bang, "+" => :plus, "-" => :minus, "*" => :multiply, "/" => :divide,
+      "%" => :modulo, "(" => :lparen, ")" => :rparen, "[" => :lbracket, "]" => :rbracket,
+      "{" => :lbrace, "}" => :rbrace, ":" => :colon, "," => :comma, ";" => :semicolon, "." => :dot
+    }.freeze
+
+    # Every operator, the longest spelling tried first.
+    OPERATOR = Regexp.union(OPERATORS.keys.sort_by { |text| -text.length })
+
+    # Scans source text.
+    #
+    # @param source [String] UTF-8 text
+    # @return [Array<Token>, Refusal] every token, the last of type `:eof`,
+    #   or the refusal that stopped the scan
+    def self.tokenize(source) = Scan.new(source).run
+
+    # One scan of one source: the scanner, the running line and column, and
+    # the tokens so far. Each call to {Lexer.tokenize} makes its own.
+    class Scan
+      include Literals
+      include Numbers
+
+      # What a character starts, tried in order; anything else is
+      # punctuation or a refusal.
+      STARTS = [[/[ \t\r\n]/, :blank], [/[0-9]/, :number], [/[A-Za-z_]/, :word], [/["']/, :string],
+                [/#/, :date]].freeze
+
+      def initialize(source)
+        @scanner = StringScanner.new(source)
+        @line = 1
+        @column = 1
+        @tokens = []
+        @chain_end = 0
+      end
+
+      # @return [Array<Token>, Refusal]
+      def run
+        until @scanner.eos?
+          start = STARTS.find { |pattern, _| @scanner.match?(pattern) }
+          refusal = start ? send(start.last) : operator
+          return refusal if refusal
+        end
+        @tokens << Token.new(type: :eof, line: @line, column: @column, length: 0)
+      end
+
+      private
+
+      def blank
+        @scanner.scan(/[ \t\r\n]+/).each_char do |char|
+          if char == "\n"
+            @line += 1
+            @column = 1
+          elsif char != "\r"
+            @column += 1
+          end
+        end
+        nil
+      end
+
+      # An identifier, a reserved word, or a function's name. A dotted name
+      # is one token only where a call follows it; anywhere else its first
+      # part stands alone and the dot is the next token. Every later part of
+      # a dotted name no call followed ends where the first did, so no call
+      # follows it either, and the name is not read again from each part.
+      def word
+        start = @scanner.pos
+        name = @scanner.scan(/[A-Za-z_][A-Za-z0-9_]*/)
+        return dotted(name) if start >= @chain_end && @scanner.match?(/\.[A-Za-z_]/)
+
+        type, value = RESERVED.fetch(name) { [:identifier, name] }
+        type = :function_name if type == :identifier && call_follows?(@scanner.pos)
+        emit(type, value, name.length)
+      end
+
+      def dotted(name)
+        chain = @scanner.check(/(?:\.[A-Za-z_][A-Za-z0-9_]*)+/)
+        after = @scanner.pos + chain.bytesize
+        if call_follows?(after)
+          @scanner.pos = after
+          return emit(:qualified_function_name, name + chain, name.length + chain.length)
+        end
+
+        @chain_end = after
+        emit(*RESERVED.fetch(name) { [:identifier, name] }, name.length)
+      end
+
+      # Whether an opening parenthesis follows the byte offset, past any
+      # whitespace. A lookahead only: the scanner is left where it was.
+      def call_follows?(offset)
+        at = @scanner.pos
+        @scanner.pos = offset
+        @scanner.match?(/[ \t\r\n]*\(/)
+      ensure
+        @scanner.pos = at
+      end
+
+      def operator
+        text = @scanner.scan(OPERATOR)
+        return emit(OPERATORS.fetch(text), text, text.length) if text
+
+        refuse("unexpected_character", "Unexpected character '#{@scanner.check(/./m)}'", @line, @column + 1)
+      end
+
+      def emit(type, value, length, **literal)
+        @tokens << Token.new(type:, line: @line, column: @column, length:, value:, **literal)
+        @column += length
+        nil
+      end
+
+      # A refusal at the running position, spanning to the end given.
+      def refuse(reason, message, end_line, end_column)
+        position = Position.new(line: @line, column: @column)
+        Refusal.new(error: ParseError.new(reason:, message:, position:),
+                    span: Span.new(start: position, end: Position.new(line: end_line, column: end_column)))
+      end
+    end
+    private_constant :Scan
+  end
+  private_constant :Lexer
+end

data/lib/predicator/parser/durations.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Predicator
+  module Parser
+    # Duration literals and the words that make one a relative date, read
+    # into the parse that includes this module.
+    #
+    # The lexer writes `3d8h` as a number and a unit per component. A literal
+    # written in whole numbers keeps its components as written, a unit
+    # written twice included. A component written with a point is expanded
+    # as the reference expands it: the whole part keeps its unit when it is
+    # not zero, and the fraction's worth, which must be a whole number of
+    # milliseconds (a month 30 days, a year 365), is spent largest first
+    # through days, hours, minutes, seconds and milliseconds, the pair
+    # `[0, unit]` standing for a component worth nothing. An inexact
+    # fraction is refused over its component; a unit named twice after an
+    # expansion is refused over the whole literal, the alphabetically first
+    # such unit named.
+    module Durations
+      # Each unit's suffix and its worth in milliseconds.
+      MILLISECONDS = DurationText::UNITS.values.to_h.freeze
+
+      # The units a fraction's worth is spent into, largest first.
+      LADDER = %w[d h m s ms].freeze
+
+      private
+
+      # The duration (or relative date) a number starts, when a unit follows
+      # it; nil when none does, and nothing is consumed.
+      def duration_from(first, start)
+        return unless at?(:duration_unit)
+
+        unit = advance
+        components = [[first, unit.value, between(start, end_of(unit))]]
+        components << component while component_follows?
+        units = whole_units(components)
+        direction(Ast::Duration.new(units:, position: start, span: between(start, end_of(previous))))
+      end
+
+      def component_follows?
+        %i[integer fractional_number].include?(peek.type) && @tokens[@index + 1].type == :duration_unit
+      end
+
+      def component
+        number = advance
+        unit = advance
+        [number.value, unit.value, between(start_of(number), end_of(unit))]
+      end
+
+      def whole_units(components)
+        written = components.map { |value, unit, _| [value, unit] }
+        return written if written.none? { |value, _| fraction?(value) }
+
+        units = components.flat_map { |parts| expanded(*parts) }
+        twice = repeated(units)
+        twice ? unit_twice(twice, components) : units
+      end
+
+      # The alphabetically first unit named more than once, if one is.
+      def repeated(units) = units.map(&:last).tally.select { |_, count| count > 1 }.keys.min
+
+      def unit_twice(unit, components)
+        refuse("duration_unit_twice", "Duration literal names the '#{unit}' unit twice after expanding a fraction",
+               nil, between(components.first.last.start, components.last.last.end))
+      end
+
+      def fraction?(value) = value.is_a?(Lexer::Fraction)
+
+      def expanded(value, unit, span)
+        return [[value, unit]] unless fraction?(value)
+
+        pairs = fraction_units(value, unit)
+        return pairs if pairs
+
+        refuse("duration_fraction", "Duration fraction is not a whole number of milliseconds: " \
+                                    "#{value.whole}.#{value.fraction}#{unit}", nil, span)
+      end
+
+      # The whole-unit pairs one component with a point is worth, or nil
+      # when its fraction is not a whole number of milliseconds.
+      def fraction_units(value, unit)
+        remainder, inexact = (Integer(value.fraction, 10) * MILLISECONDS.fetch(unit)).divmod(10**value.fraction.size)
+        return unless inexact.zero?
+
+        pairs = (value.whole.positive? ? [[value.whole, unit]] : []) + spent(remainder)
+        pairs.empty? ? [[0, unit]] : pairs
+      end
+
+      def spent(milliseconds)
+        LADDER.filter_map do |suffix|
+          amount, milliseconds = milliseconds.divmod(MILLISECONDS.fetch(suffix))
+          [amount, suffix] if amount.positive?
+        end
+      end
+
+      # `ago`, or `from now`, after a duration; the node is at the word.
+      def direction(duration)
+        return duration unless %i[ago_op from_op].include?(peek.type)
+
+        word = advance
+        last = word.type == :ago_op ? word : expect(:now_op, "expected_now", "Expected 'now' after 'from' but found")
+        Ast::RelativeDate.new(duration:, direction: word.type == :ago_op ? :ago : :future, position: start_of(word),
+                              span: reaching(duration, last))
+      end
+    end
+    private_constant :Durations
+  end
+end