{
  "category": "Operators",
  "display_name": "Implicit intersection (@)",
  "entry_kind": "built_in_operator",
  "eval_api": {
    "method": "POST",
    "url": "https://handbook.dnacalc.com/api/eval"
  },
  "function_id": "FUNC.OP_IMPLICIT_INTERSECTION",
  "implementation_state": {
    "answer_bank": null,
    "detail": "Handled by the formula layer, which owns references; answers are recorded through whole formulas, not attributed to the operator.",
    "dnacalc_commit": "9e1884369a678158dd82d3d74188daf986995e87",
    "in_catalogue": false,
    "state": "unmeasured",
    "state_label": "Implemented, no recorded answers attributed to it",
    "summary": "Implemented; no recorded answers are attributed to this entry",
    "workbook_corpus": null
  },
  "implementations": [
    {
      "commit": "9e1884369a678158dd82d3d74188daf986995e87",
      "flavour": "excel-compatibility-candidate",
      "language": "Rust",
      "name": "CalcFunc",
      "own_code": [
        "https://github.com/DnaCalc/DnaCalc/blob/9e1884369a678158dd82d3d74188daf986995e87/crates/calc-fml/src/eval/refops.rs#L116-L130",
        "https://github.com/DnaCalc/DnaCalc/blob/9e1884369a678158dd82d3d74188daf986995e87/crates/calc-fml/src/eval/refops.rs#L132-L153"
      ],
      "repository": "https://github.com/DnaCalc/DnaCalc",
      "shared_code": [
        "eval/refops::reference",
        "eval/refops::bounds",
        "eval/refops::area"
      ],
      "source": "https://github.com/DnaCalc/DnaCalc/blob/9e1884369a678158dd82d3d74188daf986995e87/crates/calc-fml/src/eval/refops.rs#L116-L130",
      "state": "unmeasured",
      "suite": null,
      "summary": "Implemented; no recorded answers are attributed to this entry"
    }
  ],
  "json_url": "https://handbook.dnacalc.com/api/functions/FUNC.OP_IMPLICIT_INTERSECTION.json",
  "name": "OP_IMPLICIT_INTERSECTION",
  "notes": [],
  "schema": "efh.function-reference/v1",
  "section_order": [
    "what-it-does",
    "try-it",
    "quirks",
    "how-to-implement",
    "version-differences",
    "alternatives"
  ],
  "sections": {
    "alternatives": "\n### Relationships\n\n\n- [`FUNC.OP_SPILL_REF`](FUNC.OP_SPILL_REF.md) — the other dynamic-array operator, and the\n  opposite motion: `#` names a whole spilled region, `@` refuses to spill.\n- [`FUNC.OP_INTERSECTION_REF`](FUNC.OP_INTERSECTION_REF.md) — the *explicit* intersection of\n  two references, spelled with a space. Despite the shared word, it is a different operation\n  with different operands; confusing the two is common and this page names the confusion\n  deliberately.\n- `SINGLE`, `_xlfn.SINGLE` — the same identity under compatibility and serialization\n  spellings (chapter 05).\n- `INDEX`, `INDIRECT`, `OFFSET`, `XLOOKUP` — reference-returning functions whose results `@`\n  consumes; the contract treats them as supporting substrate that `@` does not redefine.\n- `TAKE(x,1,1)`, `INDEX(x,1,1)` — explicit alternatives when the intent is \"the first\n  element\" rather than \"the historically intersected element\". They mean what they say; `@`\n  means something position-dependent.\n\n\n",
    "how-to-implement": "\n### Notes for implementers\n\n\n- The presence of `@` must survive parsing and binding into evaluation metadata even when the\n  stored form omits the token. The contract states this as a hard requirement, and it is the\n  single thing most likely to be got wrong: an evaluator that reconstructs `@` from the\n  stored formula text alone will lose it.\n- Keep reference identity distinct from array payload all the way to the operator. The two\n  cases scalarize differently.\n- The calling cell's position is an input. Any caching keyed only on the operand is wrong.\n- Treat the three spellings as one identity with a normalization step, not as three\n  functions.\n- This operator is `HostSerialized`: it is not safe to evaluate on an arbitrary worker thread\n  the way the arithmetic operators are.\n\n\n",
    "quirks": "\n### Result and edge cases\n\n\nReturns whatever single value the scalarization selects — a scalar of any kind, or an error.\nThe kernel class is `Custom`; there is no meaningful signature in the numeric sense.\n\n- **Scalar operand.** Passthrough.\n- **One-row or one-column range.** The cell in the caller's column or row respectively.\n- **A range that does not intersect the caller's row or column.** The historical behaviour of\n  silent implicit intersection was `#VALUE!` in this case; the contract's admitted lane\n  records `#VALUE!` for the two-dimensional case, and this page does not extend that to every\n  non-intersecting shape without evidence.\n- **Two-dimensional range.** `#VALUE!` on the admitted native baseline.\n- **Array payload.** Top-left element.\n- **Empty array.** Chapter 01 lists `#CALC!` as the error for an engine that cannot produce a\n  value, including the empty-array case. Whether `@` on an empty array reaches it is not\n  recorded here.\n- **Inside a lambda or a function argument.** The \"calling cell\" for a nested evaluation is\n  an execution-context question (chapter 04), not an operator question, and this page does\n  not settle it.\n\nNote one structural consequence: because the operator needs a workbook and a calling cell, it\ncannot be exercised by a value-only dispatch harness at all. The Handbook's mechanical\nbattery records it as not dispatchable for exactly that reason — a fact about the harness,\nnot about the operator.\n\n\n\n### Errors\n\n\n| Error | Condition |\n|---|---|\n| `#VALUE!` | The operand cannot be scalarized against the caller's position — recorded for the two-dimensional range case on the admitted baseline. |\n| any incoming error | An error operand propagates. |\n\n`data/functions/FUNC.OP_IMPLICIT_INTERSECTION.json` records no Microsoft documentation URL\n(`docs` is `null`).\n\n\n",
    "sources": "- `data/presence/FUNC.OP_IMPLICIT_INTERSECTION.json` — implementing module\n  `earlier-implementation/op_implicit_intersection.rs`, the family slug for this\n  page.\n- Handbook `content/model/05-version-axes.md` — the record that `_xlfn.SINGLE(...)` and `@`\n  are compatibility/serialization representations of one operator identity.\n- Handbook `content/model/01-value-universe.md`, `03-call-pipeline.md`,\n  `04-execution-context.md`.\n\n",
    "version-differences": "No comparison between specific Excel builds is recorded here yet. This does not establish that all builds behave alike.",
    "what-it-does": "\n`@A` reduces its operand to a single value, using the position of the *calling cell* to\ndecide which one.\n\n1. **Already a single item** — returned unchanged.\n2. **A reference or range** — scalarized relative to the caller: the same-row or same-column\n   cell of that range, chosen against the formula's anchor. A two-dimensional range yields\n   `#VALUE!` on the admitted native baseline.\n3. **An array payload** rather than a reference identity — scalarized to the top-left item.\n4. **A spill-capable expression** — removing `@` changes the publication surface from\n   scalarization to spilling, subject to host spill rules.\n\nCases 2 and 3 differ in *which* item survives, and the difference is the reason the operator\nneeds references visible: a range is scalarized positionally, an array is scalarized to its\nfirst element. An implementation that dereferences the operand before `@` sees it cannot tell\nthe two apart.\n\n### Why the character exists at all\n\nBefore dynamic arrays, a formula that handed a range to a scalar-shaped argument got this\nscalarization silently — \"implicit intersection\" is the historical name for the silent\nbehaviour. When Excel gained dynamic arrays, the same expression started spilling instead.\n`@` is the explicit marker that preserves the old meaning: it makes the intersection visible\nin the formula text so that legacy workbooks keep computing what they always computed. The\ncontract puts it plainly: explicit `@` \"is a modern surface marker for implicit-intersection\nbehavior that older Excel performed silently\".\n\nThat is also why `@` appears unbidden in formulas that were written years earlier: opening an\nold workbook in a dynamic-array build can surface the marker that was previously implicit.\nThe character is a compatibility artifact, not a new feature.\n\n### One operator, several spellings\n\nChapter 05 records `SINGLE(...)` and `_xlfn.SINGLE(...)` as compatibility and serialization\nrepresentations of this same operator identity — not separate semantics. The contract adds\nthat the host baseline normalizes `_xlfn.SINGLE(...)` back onto explicit `@` in the modern\nformula property. So a reader may encounter three spellings of one function.\n\n\n\n### Arguments\n\n\n| Position | Name | Meaning |\n|---|---|---|\n| 0 | `A` | The expression to scalarize. Required. |\n\nArity is exactly 1; no optional arguments, no defaults. The operator is prefix.\n\n"
  },
  "signature": {
    "display": "@A",
    "parameters": [],
    "trailing_repeats": false
  },
  "sources": {
    "metadata": {
      "admission": {
        "label": "formula_layer",
        "reason": null
      },
      "arity": {
        "max": 1,
        "min": 1
      },
      "category": "Operators",
      "classification": {
        "arg_preparation_profile": "RefsVisibleInAdapter",
        "coercion_lift_profile": "Custom",
        "determinism_class": "Deterministic",
        "fec_dependency_profile": "Composite",
        "host_interaction_class": "WorkbookState",
        "kernel_signature_class": "Custom",
        "surface_fec_dependency_profile": "Composite",
        "thread_safety_class": "HostSerialized",
        "volatility_class": "NonVolatile"
      },
      "descriptions": {
        "long": null,
        "short": null,
        "short_source": "no-short-description"
      },
      "docs": null,
      "entry_kind": "built_in_operator",
      "localized_family_names": null,
      "localized_names": [],
      "signature": {
        "display": "@A",
        "parameters": [],
        "trailing_repeats": false
      },
      "surface_name": "OP_IMPLICIT_INTERSECTION",
      "version_marker": null,
      "xlcall": null
    },
    "microsoft": null
  },
  "try_it": {
    "formula": "=@B1:B3",
    "inputs": {
      "B1": 9,
      "B2": 1,
      "B3": 2
    }
  },
  "url": "https://handbook.dnacalc.com/functions/OP_IMPLICIT_INTERSECTION.html",
  "variants": [],
  "versions": []
}