PROPER

What it does

PROPER(text)

PROPER(text) rewrites the case of every letter in text according to one rule, applied character by character:

A letter is uppercased if it is the first character of text or if the character before it is not a letter. Every other letter is lowercased.

That is Microsoft's documented rule, and reading it literally is the whole story — because what it says is not "capitalize each word". It says "capitalize after any non-letter". The two descriptions diverge constantly, and the divergences are the reason this function has a reputation:

None of these is a bug. All five follow from one rule with no word list, no dictionary, and no exceptions. PROPER is a character classifier, not a name formatter, and it should not be used as one.

The rule is also unconditional on the rest of the string: PROPER lowercases letters it did not capitalize, so it destroys existing casing rather than preserving it. This is what separates it from a "capitalize first letters" transformation.

Arguments

Try it

Quirks

Result and edge cases

Returns Text.

• Empty text returns the empty string.
• Non-letter characters pass through unchanged; only letters are rewritten.
• Numbers and logicals arriving in the argument slot are converted to text first under the shared coercion rules, then processed — see Coercion and lifting. What the resulting text looks like for a number is a to-text question, not a PROPER question, and the shared chapter is explicit that to-text behaviour is only outlined, not pinned.
• Error values propagate.

Errors

Microsoft's PROPER page documents no error conditions of its own. The errors reachable here are the shared ones: an error value in the argument propagates, and a value that cannot be converted to text surfaces #VALUE! under the shared coercion rules. The Handbook has not verified either against Excel.

How to implement

Notes for implementers

The whole function is a one-pass scan with one bit of state (was the previous character a letter?), so the interest is entirely in the character classification.

Three decisions have to be made, and Microsoft's documentation makes none of them:

1. What "is a letter" means. ASCII A-Za-z, the Unicode L* general categories, and the host code page's letter table are three different answers, and they differ on accented characters, on the Latin Extended blocks, and on modifier letters.
2. What case mapping is applied. Simple per-character mapping and full case mapping disagree — ß uppercases to SS under full mapping, which changes the string's length.
3. Whether the mapping is locale-sensitive. Turkish i/İ is the standing example. A locale-invariant mapping is the safer default but is a decision, not a neutral choice.

Record whichever you pick as unverified. All three are the sort of thing that silently agrees with Excel on English data and silently disagrees on everything else.

Rust code

15 proper_fn "PROPER" (1, 1) [V "text"] |s, a, sv| { cased(s, a, k::proper) }

fn adjacent_letter(chars: &[char], index: usize, offset: isize) -> bool {
    let adjacent = index as isize + offset;
    adjacent >= 0 && (adjacent as usize) < chars.len() && chars[adjacent as usize].is_alphabetic()
}

pub(crate) fn proper(text: &ExcelText) -> ExcelText {
    let chars = text.to_string_lossy().chars().collect::<Vec<_>>();
    let mut out = String::new();
    let mut start_of_word = true;
    for (index, ch) in chars.iter().copied().enumerate() {
        // PROPER treats a supplementary pair as a word boundary (fn3-proper-002).
        if ch as u32 <= 0xFFFF && ch.is_alphabetic() {
            if start_of_word {
                push_upper(&mut out, ch);
            } else {
                let is_final_sigma = ch == 'Σ'
                    && adjacent_letter(&chars, index, -1)
                    && !chars.get(index + 1).is_some_and(|&next|
                        next.is_alphabetic() || calc_value::is_combining_mark(next));
                push_lower(&mut out, ch, is_final_sigma);
            }
            start_of_word = false;
        } else {
            out.push(ch);
            start_of_word = true;
        }
    }
    text_from_str(&out)
}

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

• UPPER and LOWER are the unconditional case transforms. All three lowercase by default; PROPER differs only in which characters it raises back up.
• TEXTSPLIT / TEXTBEFORE / TEXTAFTER are what you actually want if the task is "capitalize each word" with a definition of "word" that is not "run of letters" — PROPER cannot be configured, so word-level work has to be done around it.
• There is no compatibility-replacement pair here: PROPER is neither superseded nor a retained legacy name.
• Readers confuse PROPER with TRIM, because both are reached for while cleaning imported names. They share no behaviour: TRIM deals in spaces, PROPER in case.

Named variants

No named variants are recorded yet.