ISOMITTED

What it does

ISOMITTED(argument)

ISOMITTED(argument) returns TRUE if the argument slot it was handed was left empty at the call site, and FALSE otherwise.

Microsoft's description: "Checks whether the value in a LAMBDA is missing and returns TRUE or FALSE." The argument is "The value you want to test, such as a LAMBDA parameter."

This is the only worksheet function whose subject is the value kind Missing — the marker that, in Excel's value universe, exists at exactly one boundary and nowhere else. From the value universe: Missing is "the marker for an argument that was omitted at a call site"; it is never stored in a cell, never returned by a function, never published by a formula. It is admitted at the call-argument boundary only.

ISOMITTED is how that marker becomes visible. Without it, Missing is a kind that exists in the engine and can never be observed from the sheet.

The mechanism LAMBDA supplies is the second half of the story. LAMBDA lets a user define a function with parameters; a caller may leave a parameter slot empty ((1,)); the empty slot delivers Missing to the body; ISOMITTED reads it. Microsoft's own example:

=LAMBDA(x,y, IF(ISOMITTED(y),"Missing second argument",x+y))(1,)

That is the whole design pattern — optional parameters with defaults in user-defined functions, which is what ISOMITTED exists to make possible. Before it, a LAMBDA could not distinguish "you gave me nothing" from "you gave me zero".

Arguments

argument — required, exactly one. The published signature is ISOMITTED(value).

• The intended use is a bare LAMBDA parameter name. ISOMITTED(y) inside the body of a LAMBDA(x,y,…).
• An expression is not a slot. ISOMITTED(y+0) cannot be TRUE — the addition produced a value, and a value is not missing. Wrapping the parameter in anything destroys the thing being tested.
• Outside a LAMBDA there is nothing to be missing. =ISOMITTED(A1) on a worksheet is asking about a cell reference, which was supplied. The documented subject of this function is a LAMBDA parameter; using it anywhere else is not what it is for, and the Handbook has not established what it does there.

Try it

Quirks

Result and edge cases

Returns a Logical.

• Missing is not Empty. This is the distinction the whole function rests on. A parameter bound to a reference to a blank cell received something — the Empty kind — and is not omitted. ISOMITTED should be FALSE there and ISBLANK TRUE. The two functions cover the two different nothings, and the model keeps them separate precisely so that they can.
• A parameter bound to 0 or "" is not omitted. The whole point.
• Errors do not propagate. ISOMITTED(#N/A) classifies rather than forwards, in the same way the IS-family predicates do — an error argument was supplied, so the answer is FALSE.
• Trailing omission versus interior omission. (1,) leaves a slot empty at the end; (,2) leaves one at the start. Both are omissions in the formula-text sense. Whether both deliver Missing is not established here.
• Nested LAMBDAs. A parameter forwarded from one LAMBDA to another — does the Missing marker survive the hop, so that the inner ISOMITTED sees it? Not established here, and this is the question that determines whether optional parameters compose.

Errors

ISOMITTED returns no error of its own for any argument it can be given.

Microsoft's page documents no error return.

How to implement

Notes for implementers

1. Missing must survive argument binding. If a LAMBDA invocation normalizes empty slots to Empty or to 0 before binding parameters, ISOMITTED can never return TRUE, and the failure is silent — every call just takes the non-default branch.
2. ISOMITTED must not have its argument evaluated to a value first. It needs the binding, not the binding's value. This is a lazier argument treatment than any ordinary function's.
3. Missing is admitted at exactly one boundary. It must never be storable in a cell, returnable from a function, or publishable as a result. An engine that lets Missing leak is creating a value Excel cannot represent.
4. Decide the nesting behaviour deliberately. Whether a forwarded parameter carries its Missing marker into an inner LAMBDA determines whether optional parameters compose, and it is not documented either way.
5. The battery cannot reach the TRUE case. Mechanical probing with ordinary values only ever exercises FALSE. Any test corpus for this function must be constructed by hand, inside LAMBDA invocations.

Rust code

CatalogueEntry {
    id: ISOMITTED,
    spelling: "ISOMITTED",
    notation: Notation::Call,
    arity: CallableArityShape::exact(1),
    parameters: &[Parameter::value_or_reference("argument")],
    demand: ArgumentDemand::Eager,
    kernel: Kernel::Eager(isomitted),
}

/// ISOMITTED(argument): TRUE when the argument is omitted, as a LAMBDA parameter its call did not
/// supply is (Excel 16.0, 2026-10-23: `=LAMBDA(x,[y],IF(ISOMITTED(y),x*2,x+y))(5)` is 10 and
/// `=ISOMITTED(1)` FALSE).
fn isomitted(
    arguments: &[CalcValue],
    _services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    Ok(CalcValue::logical(arguments[0].is_missing()))
}

No implementation has been published with a Handbook test suite for this function.

Version differences

No comparison between specific Excel builds is recorded here yet. This does not establish that all builds behave alike.

Alternatives

Relationships

• LAMBDA is the function ISOMITTED exists to serve; outside it, the function has no subject.
• ISBLANK is the near neighbour and the standard confusion. ISBLANK tests Empty — a cell with no content. ISOMITTED tests Missing — a call-site slot with nothing in it. Two kinds, two functions, and the model deliberately refuses to conflate them (the value universe, "Missing versus Empty").
• MAP, REDUCE, SCAN, BYROW, BYCOL, MAKEARRAY share ISOMITTED's implementation module and its callable-helper classification. They consume LAMBDA values; ISOMITTED inspects a LAMBDA's own binding.
• IF is the invariable companion: IF(ISOMITTED(y), <default>, y) is the idiom, and it is worth noting that IF is a lazy branch selector (the call pipeline), so the default expression is not evaluated when the parameter was supplied.
• LET often appears alongside, to name the defaulted value once: LET(yy, IF(ISOMITTED(y), 10, y), …).
• Optional arguments in built-in functions are the analogue this function brings to user-defined ones: every built-in with an [optional] slot performs internally the test that ISOMITTED exposes.

Named variants

No named variants are recorded yet.