ideal • runtime • patterns • sequence

Matcher for a sequence of patterns.

class sequence matcher[readonly value element type, covariant any value result type]

implements matcher[element type, result type]

procedure[result type, readonly list[any value]] matcher procedure

super(patterns list)

this • matcher procedure = matcher procedure

Parse the list and produce a result. Assumes this pattern matches the list.

implement result type parse(readonly list[element type] the list)

matches : base list[any value] • new()

var nonnegative index : 0

var nonnegative prefix : 0

while index < patterns list • size

pattern element : patterns list[index]

match : pattern element • match prefix(the list • skip(prefix))

assert match is_not null

if pattern element is matcher

matcher element : pattern element !> matcher[element type, any value]

matches • append(matcher element • parse(the list • slice(prefix, prefix + match)))

else

matches • append(missing • instance)

prefix += match

index += 1

assert prefix == the list • size

return matcher procedure(matches)