Constant Pattern

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Allowed Constant Expressions

• Numeric literals (int, float, double, etc.)
• Character and string literals ('A', "Text")
• Boolean literals (true, false)
• Enum values
• Declared const fields
• The null keyword
• default value expressions (e.g., default(T))

​

Syntax

object input = 42;
const int TargetValue = 42;

// Constant pattern using a literal
bool isZero = input is 0; 

// Constant pattern using a const field
bool isTarget = input is TargetValue; 

// Constant pattern within a switch expression
string EvaluateStatus(int statusCode) => statusCode switch
{
    200 => "OK",           // Constant pattern (integer literal)
    404 => "Not Found",    // Constant pattern (integer literal)
    _ => "Unknown"         // Discard pattern
};

​

Execution Semantics and Equality Resolution

• Implicit Conversions: When matching primitive numeric types, the constant value must be implicitly convertible to the type of the input expression. If no implicit conversion exists from the constant’s type to the expression’s type, the compiler generates an error.
• IL Optimizations: While the semantic definition relies on object.Equals, the compiler optimizes the emitted IL based on the operand types to avoid boxing overhead where possible:
  • Primitive Numerics and Enums: The compiler avoids calling object.Equals. For boxed primitives, it emits an isinst type check, unboxes the value, and performs a direct value comparison (e.g., the ceq instruction).
  • Complex Value Types: For types like decimal or custom structs (e.g., matching against default(MyStruct)), the compiler cannot use a simple ceq instruction. It emits calls to decimal.Equals, decimal.op_Equality, IEquatable<T>.Equals, or object.Equals to ensure correct semantic evaluation.
  • Strings: The compiler emits a call to string.Equals.
• Floating-Point NaN: Because the constant pattern adheres to object.Equals semantics, it handles NaN (Not-a-Number) values differently than the standard IEEE 754 equality rules applied by the == operator. While x == double.NaN always evaluates to false, the pattern x is double.NaN evaluates to true if the runtime value of x is NaN.
• Null Checking: The null constant pattern (expr is null) is a specialized form optimized to a direct reference equality check against null. It strictly bypasses any overloaded == operators on the type to guarantee an accurate, un-hijackable null check (equivalent to object.ReferenceEquals(expr, null)).

// --- Implicit Conversions 
int x = 5;
// bool match1 = x is 5L; // Compiler error: constant of type 'long' cannot be implicitly converted to 'int'

long y = 5L;
bool match2 = y is 5;     // Compiles: constant '5' (int) is implicitly converted to 'long'

// --- Floating-Point NaN 
double value = double.NaN;

// Standard equality operator follows IEEE 754 rules
bool isNanOperator = value == double.NaN; // Evaluates to false

// Constant pattern uses object.Equals semantics
bool isNanPattern = value is double.NaN;  // Evaluates to true

// --- Null Checking 
string text = null;

// Bypasses custom == operators, equivalent to object.ReferenceEquals(text, null)
bool isNull = text is null;