Insert a step pattern into the trie.

Adds a handler at the path specified by the pattern. If a handler already exists for the same keyword and pattern, it is replaced.

Parameters

• trie: The trie to insert into
• keyword: Step keyword as string (“Given”, “When”, “Then”, or “*” for any)
• pattern: Step pattern with placeholders (e.g., “I have {int} items”)
• handler: The handler to store

Example

let trie = new()
|> insert("Given", "I have {int} items", have_items)
|> insert("When", "I add {int} more", add_items)

Look up a step in the trie.

Searches for a handler matching the given keyword and step text. Returns the matched handler and captured values, or None if no match.

Lookup is O(word count) - independent of total step definitions.

Parameters

• trie: The trie to search
• keyword: Step keyword as string (“Given”, “When”, “Then”)
• text: Step text to match (e.g., “I have 42 items”)

Returns

• Some(StepMatch): Contains matched handler and captured values
• None: No step definition matched

Example

let result = lookup(trie, "Given", "I have 42 items")
case result {
  Some(StepMatch(handler, captures)) -> {
    // captures = [CapturedInt(42)]
  }
  None -> // No matching step definition
}

Create a new empty step trie.

Returns a trie with no step definitions.

Example

let trie = new()
|> insert("Given", "I have {int} items", handler)

Parse a step pattern string into segments.

Splits the pattern by whitespace and converts each token into a StepSegment. Placeholders like {int} become typed parameter segments, while other tokens become literal word segments.

Placeholder Syntax

Prefix and Suffix Handling

Placeholders can have literal prefixes and/or suffixes attached. The parser automatically splits these into separate segments:

• ${float} → [LiteralWord("$"), FloatParam]
• {int}% → [IntParam, LiteralWord("%")]
• ${float}USD → [LiteralWord("$"), FloatParam, LiteralWord("USD")]

This enables patterns like "the price is ${float}" to match text like "the price is $19.99" and capture 19.99 as the float value.

Examples

parse_step_pattern("I have {int} items")
// [LiteralWord("I"), LiteralWord("have"), IntParam, LiteralWord("items")]

parse_step_pattern("the total is ${float}")
// [LiteralWord("the"), LiteralWord("total"), LiteralWord("is"),
//  LiteralWord("$"), FloatParam]

parse_step_pattern("I apply a {int}% discount")
// [LiteralWord("I"), LiteralWord("apply"), LiteralWord("a"),
//  IntParam, LiteralWord("%"), LiteralWord("discount")]

Tokenize step text for matching.

Prepares step text for trie lookup by splitting it into tokens that align with how patterns are parsed. This enables matching patterns with prefixed or suffixed placeholders.

Tokenization Rules

1. Whitespace splitting: Text is split on spaces
2. Quote preservation: Quoted strings like "Red Widget" stay as one token
3. Numeric boundary splitting: Tokens are split at boundaries between numeric and non-numeric characters

The numeric boundary splitting is key for prefix/suffix support. When a pattern like ${float} is parsed, it becomes ["$", "{float}"]. For matching to work, the text $19.99 must also become ["$", "19.99"].

Examples

// Basic tokenization
tokenize_step_text("I have 5 items")
// ["I", "have", "5", "items"]

// Quoted strings preserved
tokenize_step_text("I add \"Red Widget\" to cart")
// ["I", "add", "\"Red Widget\"", "to", "cart"]

// Currency prefix split from number
tokenize_step_text("the total is $19.99")
// ["the", "total", "is", "$", "19.99"]

// Percentage suffix split from number
tokenize_step_text("I apply a 15% discount")
// ["I", "apply", "a", "15", "%", "discount"]

// Multiple numeric boundaries
tokenize_step_text("price is $99.99USD")
// ["price", "is", "$", "99.99", "USD"]