Rust already supports a wide range of unicode characters in identifiers - for example α, номер, عدد, 数, संख्या are all valid Rust identifiers. This RFC extends the set of Unicode character which can be used in identifiers with ID_Compat_Math_Start and ID_Compat_Math_Continue, most notable: ∇, ∂, ∞, subscripts ⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ and superscripts ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎. This can be a boon to implementers of scientific concepts as they can write for example let ∇E₁₂ = 0.5;.

Motivation

Programming languages have historically focused on the quite narrow set of ASCII characters, however developers from other cultures or specialized problem spaces can benefit from using characters which are native to their culture or domain. The vast body of scientific literature uses a variety of characters to express concepts from physics, mathematics, biology, robotics and many others. Symbols often appearing in equations are Roman letters like x, Greek letters like θ, and differentiation operators like ∂ and ∇. Variables are often adorned with subscripts like x₁₂ or superscripts like x⁺ or x⁽²⁾. Having these symbols available as Rust identifiers could simplify the implementation of these concepts and stay closer to a reference publication, thus reducing confusion and implementation errors.

For example instead of:

let gradient_energy_1 = 2.0 * (position_1 - center_1);
let gradient_energy_2 = 2.0 * (position_2 - center_2);

one could write:

let ∇E₁ = 2.0 * (p₁ - c₁);
let ∇E₂ = 2.0 * (p₂ - c₂);

A longer example from the "wilds":

fn strain_energy_hessian_coeffs(l0: f64, l: f64) -> [f64; 4] {
    let l02 = l0.powi(2);
    let l03 = l0 * l02;
    let l04 = l0 * l03;
    let l05 = l0 * l04;
    let l2 = l.powi(2);
    let l3 = l * l2;

    let h = (l02 - l2) / (2.0 * l03);
    let dh = (3.0 * l2 - l02) / (2.0 * l05);

    [1.0 / l3, -1.0 / l03, dh, 1.0 / l0 - 1.0 / l + h]
}

With this RFC one could write:

fn strain_energy_hessian_coeffs(l₀: f64, l: f64) -> [f64; 4] {
    let l₀² = l₀.powi(2);
    let l₀³ = l₀ * l₀²;
    let l₀⁴ = l₀ * l₀³;
    let l₀⁵ = l₀ * l₀⁴;
    let l² = l.powi(2);
    let l³ = l * l²;

    let h = (l₀² - l²) / (2.0 * l₀³);
    let dh = (3.0 * l² - l₀²) / (2.0 * l₀⁵);

    [1.0 / l³, -1.0 / l₀³, dh, 1.0 / l₀ - 1.0 / l + h]
}

Guide-level explanation

If needed you can use mathematical symbols like θ, ∇, or ∂ as part of an identifier when implementing scientific concepts.

In addition you can use subscript and superscripts for your identifiers, for example you can write x₁₂ instead of x_12, or x⁺ instead of x_plus. Note that you cannot start an identifier with a subscript or superscript, for example ₁x will give a compiler error.

Reference-level explanation

The Unicode sets ID_Compat_Math_Start and ID_Compat_Math_Continue as defined in Unicode Standard Annex #31 (UAX31) are part of the Unicode mathematical compatibility notation profile and consist of the following characters:

∂ and ∇ from Miscellaneious mathematical symbols,
∞ from Miscellaneous mathematical symbol,
₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ from Subscripts,
⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ from Superscripts and Latin-1 punctuation and symbols,
𝛁𝛛𝛻𝜕𝜵𝝏𝝯𝞉𝞩𝟃 (italic and bold versions of ∂ and ∇) from various sets like Bold Greek symbols.

The characters 1) - 4) are added to the set of characters allowed in Rust identifiers. UAX31 notes that "supporting these characters is recommended for some computer languages because they can be beneficial in some applications".

In other words this RFC proposes to adopt the "Mathematical Compatibility Notation Profile" which in accordance with UAX31-R3b allows these characters in identifiers and in turn prevents syntactic use. For example let a = 2.0; let b = a²; will naturally give a compiler error that a² is an unknown identifier and not be interpreted as let b = a * a;. Similarly let a = [2, 0]; let b = a₁; will naturally give a compiler error that a₁ is an unknown identifier and not be interpreted as let b = a[0];. ∞ will just be a character usable in identifiers and not be a synonym to the likes of f32::INFINITY.

The characters 5) are added to the set of Rust identifiers, but will trigger an NFKC or uncommon_codepoints warning when used depending on their Unicode classification. For example using 𝛁 in an identifier will trigger:

warning: identifier contains a non normalized (NFKC) character: '𝛁'

similarly to how characters like 𝑥 (instead of x) or 𝑓 (instead of f) are triggering this warning in stable Rust today. This follows the guidelines from the Unicode Technical Standard #55 - Source Code Handling (UTS55) which recommends that "implementations should provide a mechanism to warn about identifiers that are not in the General Security Profile for Identifiers" as defined in the Unicode Technical Standard #39 - Unicode Security Mechanisms (UTS39). In particular the characters in 5) are identified as "Not_NFKC", i.e. characters that cannot occur in strings normalized to NFKC.

Note that Unicode specifically mentions Rust as a positive industry example that follows the recommendations from the General Security Profile.

Drawbacks

Characters like 𝛁𝛛𝛻𝜕𝜵𝝏𝝯𝞉𝞩𝟃 are easily confusable with their base versions ∂∇ and can lead to subtle bugs. However the precedent in Rust is to add them alongside their base version, but trigger the NFKC warning.
Some developers prefer to only use ASCII characters for programming. This paradigm can be enforced today via deny(non_ascii_idents). This would disallow all characters added by this RFC.
The superscript characters could be confused with actual mathematical operations. For example someone might write let a = 2.0; let b = 3.0 * a²; and be confused that this will result in a compiler error. There might also be the potential for subtle bugs like let a² = 2; let a = 2; let x = a²; and erronously assuming that x = 4, however one can argue that this is not due to the superscript characters as it can happen as well when only using ASCII characters: let a_sq = 2; let a = 2; let x = a_sq;.
The subscript characters could be confused with indexing operation. For example someone might write let a = [2, 0]; let b = a₁; and be confused that this will result in a compiler error.
Some people might find it difficult to read superscript and subscript letters on lower resolution screens or when using small font sizes.

Rationale and alternatives

If this RFC is not implemented then everyone has to keep using ASCII characters for identifiers in scientific code, for example gradient_energy or a_12.

The impact of not implementing it should be fairly small, but implementing it could invite more scientific oriented people to the Rust language and make it easier for them to implement complex concepts.

Alternatively Rust could decide to give the proposed characters syntatic meaning.

Superscript characters could be interpreted as exponentiation, for example let a = 2; let b = a²; could be a synonym to let a = 2; let b = a * a;. This would open up a host of questions and potential issues, like:

Should a²⁻³ be interpreted as 1/a?
There is no superscript character for multiplication * or division /.

∞ could be a synonym or replacement to f32::INIFITY, however there is no precedent for using non-ASCII characters in core/std and this would likely meet considerable opposition.

Derivatives could be added as a language feature using auto-differentiation techniques and ∇ and ∂ could be given syntactic meaning. For example Mathematica supports the syntax ∂ₓf for a partial derivative of f with respect to x and the syntax ∇ₓf for the gradient with respect to x. Moreover there is an experimental feature for Rust which provides auto-differentiation via an attribute macro #[autodiff_forward(name, ..)] with a user-provided function name for the automatically generated derivative. With this RFC ∇f could be used as the function name, i.e. #[autodiff_forward(∇foo, ..)]. However Rust could also decide to automatically use ∇foo as the derivatives of foo, and give ∇ syntactic meaning.

Subscript characters could be given syntatic meaning, for example a₁ could be a synonym to a[1], however this would be highly contentious and error prone due to the general disagreement between 0-based versus 1-based indexing and would suffer from similar problems as using superscripts for exponentiation.

Prior art

Rust has the philosophy to be open to various cultures and languages and allow them use their native symbols as identifiers. Example which compiles in stable Rust without warning:

fn main() {
    let λ = 2.718_f32;  // Greek letter lambda
    let 파이 = 3.141_f32;  // Korean word for "pie"
    let значення = λ.abs() + 파이.abs();  // Cyrillic
    println!("{значення}");
}

Many of these characters are easily confusable if not attuned to the corresponding language or culture. Example which compiles in stable Rust without warning:

fn main() {
    let 鳯 = 3;  // U+9CF5: "phoenix" (old variant)
    let 鳳 = 4;  // U+9CF4: modern simplified/traditional
    let 隱 = 5;  // U+96B1: “hidden”
    let 隠 = 6;  // U+96B0: nearly identical glyph
    println!("鳯 = {}, 鳳 = {}", 鳯, 鳳);
    println!("隱 = {}, 隠 = {}", 隱, 隠);
}

A vast set of characters added as part of Unicode character sets are easily confusable with other characters. Example which compiles in stable Rust and triggers a "warning: identifier contains a non normalized (NFKC) character":

fn main() {
    let l = 1.0;
    let ℓ = l + 2.0;
    let 𝑓𝑢𝑛𝑐 = |𝑥: f32| 𝑥 * ℓ + l;
    let Σ = (1..5).map(|𝑖| 𝑓𝑢𝑛𝑐(𝑖 as f32)).sum::<f32>();
    println!("∑: {Σ}");
}

There are characters which one might argue should never have been added but are part of allowed Unicode sets. Example which compiles in stable Rust and triggers a "warning: identifier contains an uncommon character":

fn ᅟ() {  // U+115F (Hangul Choseong Filler) renders as blank
    println!("boo");
}

fn main() {
    ᅟ();  // dito
}

Note that the character is the name of the function, even though it renders inside the parentheses in some browsers.

C++ P3658R0 is a similar proposal with similar reasoning for the C++ language. In particular it states that the characters suggested in this RFC where allowed in C++11 to C++20 as originally published.

Unresolved questions

Are there other character sets which could be added as part of this RFC?
Should the italic and bold versions of characters ∂ and ∇ be added?

Future possibilities

Rust has chosen the path of allowing non-ASCII characters as identifiers and this RFC adds some more characters which are useful to the scientific domain.

There might be other useful sets of characters which could be added in the future.

compat_math_identifiers