In a Karate `match`, what do the inline markers `'#(^part)'`, `'#(^^part)'`, `'#(^*part)'` and `'#(^+part)'` mean, and what can they express that the `contains` step spellings cannot?

## The operator, moved inside the payload Every containment operator in Karate has a two-character (or one-character) prefix that can be written inside an **embedded expression** on the expected side. The right-hand side is a string of the form `'#(<prefix><expression>)'`; Karate strips the prefix, evaluates the rest as JavaScript in scenario scope, and runs the resulting value through the operator the prefix named. | inline marker | equivalent step | |---|---| | `'#(^part)'` | `match actual contains part` | | `'#(^^part)'` | `match actual contains only part` | | `'#(^*part)'` | `match actual contains any part` | | `'#(^+part)'` | `match actual contains deep part` | | `'#(!^part)'` | `match actual !contains part` | | `'#[] ^partSchema'` | `match each actual contains partSchema` | Note the `each` row: inside the array-marker form the prefix is written **without** parentheses, directly after `#[]`. The same shape gives `'#[] ^*mixSchema'` for `each contains any` and `'#[] !^badSchema'` for `each !contains`. The `each` rows take a marker rather than a literal on purpose: `each` applies the containment to **every** element, so an expected value such as `{ a: 1 }` has to hold for all of them. Against `[{ a: 1, b: 'x' }, { a: 2, b: 'y' }]` it does not — the child comparison for a named key is equality, `2` is not `1`, and the step fails at index 1. ## What only the inline form can say If every marker had a step equivalent the feature would be sugar. It has two jobs that the step grammar cannot do at all. **1. Containment at a nested position.** A step-level operator applies to the whole comparison. The inline form applies to one field: ```gherkin * def created = [{ id: 23, name: 'Bob' }, { id: 42, name: 'Wild' }] * match response == { id: '#number', name: 'Billie', kittens: '#(^^created)' } ``` That single step pins the exact shape of the response object — no extra keys, `id` a number, `name` exactly `'Billie'` — while comparing `kittens` order-insensitively. There is no way to write that with one step-level operator, because the operator would have to be `==` and `contains only` at the same time. **2. Containment inside containment.** The two forms compose in the other direction as well: ```gherkin * def actual = [{ a: 1, b: 'x' }, { a: 2, b: 'y' }] * def part = { a: 1 } * match actual contains '#(^part)' ``` The outer `contains` scans the array; the inner `^` makes each element compared with containment rather than equality. In words: *the array holds an element that itself contains `part`.* Written as `match actual contains part` it would fail, because the element `{ a: 1, b: 'x' }` would have to **equal** `{ a: 1 }`. The upstream test suite marks exactly these lines `no in-line equivalent!` in the other direction — they are the cases with no step spelling. `'#(^*mix)'` and `'#(^+part)'` compose the same way inside an outer `contains`. ## Where it stops - **Two operators have no inline shortcut at all**: `contains only deep` and `contains any deep`. The prefix table simply has no entry for them. `contains only deep` is still writable as a step. `contains any deep` is not, on Karate 1.x: the step parser recognises exactly four suffixes — `only deep`, `only`, `any`, `deep` — with no `any deep` rung, so `match x contains any deep y` matches `any`, swallows the word `deep` into the expected expression and degrades silently to `contains any`. It became a real step spelling only in 2.x. - The prefix is matched longest-first, so `^^`, `^*` and `^+` are recognised before the bare `^`. A stray space — `'#( ^part)'` — is not the same string and will not be read as a prefix. - The whole marker is an ordinary single-quoted string in the feature file. That is what lets it sit as a **value** inside a JSON literal, and it is also why a missing quote turns the caret into a syntax error rather than into a silently different assertion. - `'#(...)'` with no prefix is plain equality against the evaluated value, which is the ordinary embedded-expression form; the caret family is a strict extension of it. - The expression inside the parentheses is JavaScript evaluated in scenario scope, so it is normally a variable name, but any expression that yields a map, list or string works. ## Why this exists It is the same design idea as Karate's `#`-markers generally: the expected value is a literal you can read, and the operators live inside it rather than in a matcher chain built up in Java. A schema file becomes a reusable variable, and the caret prefixes let one schema be applied strictly in one assertion and loosely in another without editing the schema itself: ```gherkin * def schema = { a: '#number', b: '#string' } * def partSchema = { a: '#number' } * match actual[0] == schema * match actual[0] == '#(^partSchema)' * match actual == '#[] schema' * match actual == '#[] ^partSchema' ``` Read top to bottom, those four lines are exact-shape, partial-shape, exact-shape-for-every-element and partial-shape-for-every-element — four different strictnesses over two reusable variables, with no assertion objects anywhere. The cost is legibility: a reviewer who has not memorised the prefix table sees `'#(^^created)'` as noise, so the notation earns its place where the step grammar genuinely cannot express the assertion, and rarely anywhere else.