{
  "category": "Operators",
  "display_name": "Unary plus (+)",
  "entry_kind": "built_in_operator",
  "eval_api": {
    "method": "POST",
    "url": "https://handbook.dnacalc.com/api/eval"
  },
  "function_id": "FUNC.OP_UNARY_PLUS",
  "implementation_state": {
    "answer_bank": null,
    "detail": "",
    "dnacalc_commit": "9e1884369a678158dd82d3d74188daf986995e87",
    "in_catalogue": true,
    "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-func/src/catalogue/arithmetic.rs#L44-L44",
        "https://github.com/DnaCalc/DnaCalc/blob/9e1884369a678158dd82d3d74188daf986995e87/crates/calc-func/src/catalogue/arithmetic.rs#L176-L197"
      ],
      "repository": "https://github.com/DnaCalc/DnaCalc",
      "shared_code": [],
      "source": "https://github.com/DnaCalc/DnaCalc/blob/9e1884369a678158dd82d3d74188daf986995e87/crates/calc-func/src/catalogue/arithmetic.rs#L44-L44",
      "state": "unmeasured",
      "suite": null,
      "summary": "Implemented; no recorded answers are attributed to this entry"
    }
  ],
  "json_url": "https://handbook.dnacalc.com/api/functions/FUNC.OP_UNARY_PLUS.json",
  "name": "OP_UNARY_PLUS",
  "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_NEGATE`](FUNC.OP_NEGATE.md) — the coercing unary sibling. The pair is the clean\n  experiment: run identical operands through `-A` and `+A` and the coercion doctrine of each\n  becomes visible in one screenshot.\n- [`FUNC.OP_ADD`](FUNC.OP_ADD.md) — same character, two operands.\n- `N`, `VALUE`, `T` — the explicit coercion functions. If a formula wants a number, one of\n  these says so; `+A` does not, under either reading.\n- The `--A` double-unary idiom uses [`FUNC.OP_NEGATE`](FUNC.OP_NEGATE.md) twice, not this\n  operator, and its coercing effect is well established — which is itself circumstantial\n  support for reading 2, since nobody would need `--` if `+` already coerced.\n\n\n",
    "how-to-implement": "\n### Notes for implementers\n\n\n- Decide the reading explicitly and record it. An implementation that silently routes `+A`\n  through the shared unary-numeric path has chosen reading 1 by omission — which is exactly\n  the shape `BUG-FUNC-029` describes as its root cause (a coercing surface reused for an\n  identity operator).\n- If you implement reading 2, the operator is not a numeric kernel at all and does not belong\n  behind a `NumToNum` signature; its array path must map kinds elementwise, not values.\n- Under either reading, error operands propagate and the operator is `SafePure`,\n  `Deterministic`, `NonVolatile`.\n- Do not let the leading-`+` typing habit reach a different code path from an inner `+A`.\n  They are the same operator.\n\n\n",
    "quirks": "\n### Result and edge cases\n\n- **Number operand.** Both readings return the same number. The `BUG-FUNC-029` fix note\n  additionally describes an underflow normalization on the number path; the Handbook has not\n  characterized that behaviour and does not restate it as a rule here.\n- **Text operand.** The pivot case. Reading 1 coerces (and fails with `#VALUE!` on\n  non-numeric text); reading 2 returns the text unchanged, so `+\"abc\"` would be `\"abc\"`\n  rather than an error. These differ not only in value but in whether an error occurs at all.\n- **Logical operand.** Reading 1 gives 1 or 0; reading 2 gives `TRUE` or `FALSE`.\n- **Blank operand.** The `BUG-FUNC-029` record describes blank/empty mapping to 0 among the\n  operand semantics it measured before coding. Cited as an upstream observation, not as a\n  Handbook claim.\n- **Error operand.** Propagates under both readings.\n- **Arrays.** Elementwise under both readings; under reading 2 the mapping preserves each\n  element's own kind.\n\n\n\n### Errors\n\n`data/functions/FUNC.OP_UNARY_PLUS.json` records no Microsoft documentation URL (`docs` is\n`null`). No Microsoft page is cited here for the type-preservation question, and the\nHandbook has not found one that settles it.\n\n\n",
    "sources": "- `data/presence/FUNC.OP_UNARY_PLUS.json` — implementing module\n  `earlier-implementation/operator_arithmetic_family.rs`, and the listing of\n  `BUG-FUNC-029` as a behavioural-finding document for this row.\n- Handbook `content/model/01-value-universe.md`, `02-coercion-and-lifting.md`,\n  `03-call-pipeline.md`, `06-claim-language.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` returns its operand. The whole question on this page is *how much* of the operand it\nreturns — the value alone, or the value together with its type.\n\nThere are two candidate readings, and they are not compatible:\n\n**Reading 2 — type-preserving identity.** `+A` returns the operand unchanged, including its\nkind: text stays text, a logical stays a logical, a number stays that number. Under this\nreading `+\"2\"` is the *text* `2` and `+TRUE` is the *logical* `TRUE`.\n\nFor number operands the two readings agree, which is why the discrepancy survived: almost\nevery real use of `+A` in a workbook has a numeric operand.\n\n\n\n### Arguments\n\n\n| Position | Name | Meaning |\n|---|---|---|\n| 0 | `A` | The operand. Required. |\n\nArity is exactly 1; no optional arguments, no defaults.\n\nThe same `+` character in infix position is [`FUNC.OP_ADD`](FUNC.OP_ADD.md), a two-argument\nfunction with a different operand doctrine. A leading `+` typed at the start of a formula\n(`+A1*2`, the habit inherited from Lotus 1-2-3 keyboards) is this operator applied to the\nrest of the expression — which is why the distinction is not academic: millions of formulas\nbegin with it.\n\n\n"
  },
  "signature": {
    "display": "+number",
    "parameters": [
      {
        "description": null,
        "name": "number",
        "optional": false,
        "repeats": false
      }
    ],
    "trailing_repeats": false
  },
  "sources": {
    "metadata": {
      "admission": {
        "label": "implemented",
        "reason": null
      },
      "arity": {
        "max": 1,
        "min": 1
      },
      "category": "Operators",
      "classification": {
        "arg_preparation_profile": "ValuesOnlyPreAdapter",
        "coercion_lift_profile": "UnaryNumericScalarOrArrayElementwise",
        "determinism_class": "Deterministic",
        "error_collapse_profile": "None",
        "fec_dependency_profile": "None",
        "host_interaction_class": "None",
        "kernel_signature_class": "NumToNum",
        "rich_value_usage": "RichBlind",
        "surface_fec_dependency_profile": "RefOnly",
        "thread_safety_class": "SafePure",
        "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": "+number",
        "parameters": [
          {
            "description": null,
            "name": "number",
            "optional": false,
            "repeats": false
          }
        ],
        "trailing_repeats": false
      },
      "surface_name": "OP_UNARY_PLUS",
      "version_marker": null,
      "xlcall": null
    },
    "microsoft": null
  },
  "try_it": {
    "formula": "=+2"
  },
  "url": "https://handbook.dnacalc.com/functions/OP_UNARY_PLUS.html",
  "variants": [],
  "versions": []
}