Indexed Types / Constraint Domain System for C#

[xtofs]

Indexed Types: A Constraint Domain System for C#

Abstract

This document proposes a compiler extension for C# that enables lightweight indexed types - a generalization of F#'s units-of-measure system.

The core idea is to attach compile-time indices to types, making values with different indices incompatible by default. For example, a Quantity<Length> cannot be added to a Quantity<Time> — the compiler rejects such operations. However, controlled compatibility is possible through operations that transform indices: dividing Quantity<Length> by Quantity<Time> yields Quantity<Velocity>, where the resulting index is computed from the operands.

The key innovation is allowing users to define custom constraint domains where types can be indexed by elements from user-defined algebraic structures. The compiler performs constraint solving during type inference, then erases all index information before code generation, resulting in zero runtime overhead.

1. Introduction

1.1 Motivation

Many programming domains benefit from tracking additional type-level information that doesn't affect runtime behavior:

• Physical units: Preventing mixing of meters and seconds
• Security levels: Tracking information flow through a system
• Effect systems: Tracking IO, exceptions, or other side effects
• Size tracking: Ensuring array dimensions are compatible
• Region types: Tracking memory lifetimes

Current approaches in other languages using phantom types or type-level programming are verbose and are challenges by proper type inference. This proposal introduces a systematic way to add such tracking with minimal syntactic overhead.

1.2 Design Goals

Zero runtime cost: All index information erased before code generation
Automatic inference: Type checker solves constraints automatically
User extensibility: Users can define new domains without compiler changes
Natural syntax: Leverage existing C# syntax and operators
Type safety: All checking happens at compile time

1.3 Relationship to Existing Work

This proposal generalizes Andrew Kennedy's units-of-measure system from F#, making it:

• Extensible: Not limited to physical dimensions
• User-defined: Domains defined in user code, not compiler
• Operator-based: Uses C# operators rather than special syntax

2. Core Concepts

2.1 Indexed Types

An indexed type is a type parameterized by an index from a constraint domain:

Quantity<TDim>
    where TDim : index DimensionDomain

Where:

• Quantity is the base type
• TDim is an index variable (looks like a regular type parameter but is not strictly a type)
• index DimensionDomain is a constraint marking it as an index parameter
• The index comes from the specified constraint domain

2.2 Constraint Domains

A constraint domain defines:

• An index type (e.g., Dimension, SecurityLevel)
• Operations on indices (defined as methods or operators on the index type)
• Optionally, a Normalize() method for canonical representation (see below)

The Normalize Method (Optional)

After evaluating an index expression, the compiler checks if the index type defines a Normalize() method. If present, it is called to reduce the result to a canonical form before type unification.

Normalization is required when:

• The same logical value can have multiple representations (e.g., fractions 2/4 and 1/2)
• Operations produce non-canonical results that must be compared for equality

Normalization is not needed when:

• The index type's representation is already canonical by construction
• Dimension(0, 1, 0) has only one representation for "Length"
• SecurityLevel(2) has only one representation for "Secret"
• Record/struct equality already works correctly without reduction

For a detailed example where normalization is essential, see Appendix A.

Example Domain (no normalization needed):

// Index type with operations
public record Dimension(int M, int L, int T)
{
    public static Dimension operator *(Dimension a, Dimension b)
        => new(a.M + b.M, a.L + b.L, a.T + b.T);
    
    public static Dimension operator /(Dimension a, Dimension b)
        => new(a.M - b.M, a.L - b.L, a.T - b.T);
    
    // No Normalize() needed: integer tuples are already canonical
}

// Domain declaration (minimal, no solver)
public static class DimensionDomain
{
    public static Type IndexType => typeof(Dimension);
}

2.3 Index Expressions

Index expressions appear in type positions and use the operations defined on the index type:

Quantity<TResult>
    where TResult : index DimensionDomain(TDim1 * TDim2)

Quantity<TResult>
    where TResult : index DimensionDomain(TDim1 / TDim2)

Quantity<TResult>
    where TResult : index DimensionDomain(TDim.Power(2))

The compiler translates these to actual operations on the index type.

3. Syntax Extensions

3.1 Index Parameter Constraints

Type parameters can be constrained as indices using the index keyword in where clauses:

public struct Quantity<TDim>
    where TDim : index DimensionDomain
{
    public double Value { get; init; }
}

This follows the familiar C# pattern:

// Index constraint (NEW)
where TDim : index DimensionDomain

3.2 Index Expressions in Constraints

Index expressions can appear in where clauses.

The syntax is: where T : index Domain(expression), naming the domain and writing the expression in familar C# expression syntax:

public struct Quantity<TDim>
    where TDim : index DimensionDomain
{
    public static Quantity<TResult> operator *(
        Quantity<TDim1> a,
        Quantity<TDim2> b)
        where TDim1 : index DimensionDomain
        where TDim2 : index DimensionDomain
        where TResult : index DimensionDomain(TDim1 * TDim2)
    {
        return new Quantity<TResult> { Value = a.Value * b.Value };
    }
}

3.3 Syntax Variations

Several syntactic forms for index expressions:

// Binary operators
where TResult : index DimensionDomain(TDim1 * TDim2)
where TResult : index DimensionDomain(TDim1 / TDim2)

// Method calls
where TResult : index DimensionDomain(TDim.Power(2))
where TResult : index DimensionDomain(TDim.Inverse())

// Properties
where TResult : index DimensionDomain(TDim.Squared)

// Constants
where TDim : index DimensionDomain(Dimensions.Length)

3.4 Alternative: Expression After Colon

For brevity, the domain could be inferred from context:

public static Quantity<TResult> operator *(
    Quantity<TDim1> a,
    Quantity<TDim2> b)
    where TDim1 : index DimensionDomain
    where TDim2 : index DimensionDomain
    where TResult : index TDim1 * TDim2  // Domain inferred
{
    return new Quantity<TResult> { Value = a.Value * b.Value };
}

This is terser but potentially ambiguous. The full form index Domain(expr) is clearer.

4. Type Inference and Constraint Solving

4.1 Constraint Generation

When the compiler encounters operations on indexed types, it generates index constraints:

// User code
var velocity = distance / time;

// Compiler infers
// distance : Quantity<Length>
//              where Length : index DimensionDomain
// time     : Quantity<Time>
//              where Time : index DimensionDomain
// velocity : Quantity<TResult>
//              where TResult : index DimensionDomain(Length / Time)

4.2 Constraint Solving

The compiler solves constraints by:

1. Evaluating known index expressions
2. Invoking operations defined on the index type
3. Normalizing results (if the index type defines a Normalize method)
4. Unifying results with expected types

To solve: TResult where TResult : index DimensionDomain(Length / Time)

• Step 1: Load Dimension values
  • Length = Dimension(0, 1, 0)
  • Time = Dimension(0, 0, 1)
• Step 2: Invoke Dimension.operator /(Length, Time)
  • Result = Dimension(0, 1, -1)
• Step 3: Bind TResult := Dimension(0, 1, -1)

The Dimension type is already in normal form (integer exponents), so no normalization step is needed. For an example where normalization is required, see Appendix A: Normalization Example.

4.3 Type Erasure

After type checking, all index information is erased:

// Before erasure (compile-time type)
Quantity<TDim>
    where TDim : index DimensionDomain(Dimension(0, 1, -1))

// After erasure (runtime type)

Quantity
// Generated IL contains no dimension information

5. Example: Units of Measure

5.1 Domain Definition

// Index type
public record Dimension(int M, int L, int T)
{
    public static Dimension operator *(Dimension a, Dimension b)
        => new(a.M + b.M, a.L + b.L, a.T + b.T);
    
    public static Dimension operator /(Dimension a, Dimension b)
        => new(a.M - b.M, a.L - b.L, a.T - b.T);
    
    public static Dimension Power(Dimension d, int exp)
        => new(d.M * exp, d.L * exp, d.T * exp);
    
    public Dimension Inverse() => new(-M, -L, -T);
    
    public static Dimension Identity => new(0, 0, 0);
    
    public override string ToString()
    {
        var parts = new List<string>();
        if (M != 0) parts.Add($"M{(M == 1 ? "" : $"^{M}")}");
        if (L != 0) parts.Add($"L{(L == 1 ? "" : $"^{L}")}");
        if (T != 0) parts.Add($"T{(T == 1 ? "" : $"^{T}")}");
        return parts.Count > 0 ? string.Join("·", parts) : "1";
    }
}

// Domain declaration
public static class DimensionDomain
{
    public static Type IndexType => typeof(Dimension);
}

// Standard dimensions
public static class Dimensions
{
    public static readonly Dimension Length = new(0, 1, 0);
    public static readonly Dimension Mass = new(1, 0, 0);
    public static readonly Dimension Time = new(0, 0, 1);
    
    // Derived dimensions
    public static readonly Dimension Velocity = Length / Time;
    public static readonly Dimension Acceleration = Velocity / Time;
    public static readonly Dimension Force = Mass * Acceleration;
}

5.2 Quantity Type

public struct Quantity<TDim>
    where TDim : index DimensionDomain
{
    public double Value { get; init; }
    
    public static Quantity<TResult> operator *(
        Quantity<TDim1> a,
        Quantity<TDim2> b)
        where TDim1 : index DimensionDomain
        where TDim2 : index DimensionDomain
        where TResult : index DimensionDomain(TDim1 * TDim2)
    {
        return new Quantity<TResult> { Value = a.Value * b.Value };
    }
    
    public static Quantity<TResult> operator /(
        Quantity<TDim1> a,
        Quantity<TDim2> b)
        where TDim1 : index DimensionDomain
        where TDim2 : index DimensionDomain
        where TResult : index DimensionDomain(TDim1 / TDim2)
    {
        return new Quantity<TResult> { Value = a.Value / b.Value };
    }
    
    public static Quantity<TDim> operator +(
        Quantity<TDim> a,
        Quantity<TDim> b)
        where TDim : index DimensionDomain
    {
        return new Quantity<TDim> { Value = a.Value + b.Value };
    }
    
    public static Quantity<TDim> operator -(
        Quantity<TDim> a,
        Quantity<TDim> b)
        where TDim : index DimensionDomain
    {
        return new Quantity<TDim> { Value = a.Value - b.Value };
    }
    
    public static Quantity<TResult> Square<TResult>(
        Quantity<TDim> x)
        where TDim : index DimensionDomain
        where TResult : index DimensionDomain(TDim.Power(2))
    {
        return x * x;
    }
    
    public override string ToString() => $"{Value:F2}";
}

### 5.3 Usage Example

```csharp
class Physics
{
    public void CalculateForce()
    {
        // Define quantities with dimensions
        var distance = new Quantity<Dimensions.Length> { Value = 100.0 };
        var time = new Quantity<Dimensions.Time> { Value = 5.0 };
        var mass = new Quantity<Dimensions.Mass> { Value = 10.0 };
        
        // Type inference works automatically
        var velocity = distance / time;
        // Inferred: Quantity<TResult>
        //   where TResult : index DimensionDomain(Dimension(0,1,-1))
        
        var acceleration = velocity / time;
        // Inferred: Quantity<TResult>
        //   where TResult : index DimensionDomain(Dimension(0,1,-2))
        
        var force = mass * acceleration;
        // Inferred: Quantity<TResult>
        //   where TResult : index DimensionDomain(Dimension(1,1,-2))
        
        Console.WriteLine($"Force: {force} N");
        
        // Compile-time error: incompatible dimensions
        // var wrong = distance + time;
    }
    
    // Generic function polymorphic over dimensions
    public Quantity<TResult> Square<TDim, TResult>(
        Quantity<TDim> x)
        where TDim : index DimensionDomain
        where TResult : index DimensionDomain(TDim.Power(2))
    {
        return x * x;
    }
    
    // Works for any dimension
    public void TestSquare()
    {
        var length = new Quantity<Dimensions.Length> { Value = 5.0 };
        var area = Square(length);
        // Type: Quantity<TResult>
        //   where TResult : index DimensionDomain(Dimension(0,2,0))
        
        var time = new Quantity<Dimensions.Time> { Value = 3.0 };
        var timeSquared = Square(time);
        // Type: Quantity<TResult>
        //   where TResult : index DimensionDomain(Dimension(0,0,2))
    }
}

5.4 Type Aliases for Readability

// Define convenient aliases
public static class QuantityAliases
{
    public static Quantity<TDim> Create<TDim>(double value)
        where TDim : index DimensionDomain
        => new() { Value = value };
}

// Or with using directives (if supported)
using Length = Quantity<Dimensions.Length>;
using Time = Quantity<Dimensions.Time>;
using Mass = Quantity<Dimensions.Mass>;
using Velocity = Quantity<Dimensions.Velocity>;
using Acceleration = Quantity<Dimensions.Acceleration>;
using Force = Quantity<Dimensions.Force>;

6. Example: Information Flow Security

6.1 Domain Definition

// Index type: security levels form a lattice
// Note: We use a readonly struct instead of an enum because C# enums
// cannot have operators defined on them. The struct wraps the level value
// and provides the lattice operations as operators.
public readonly record struct SecurityLevel
{
    private SecurityLevel(int level) => Level = level;
    
    public int Level { get; }
    
    // Predefined levels
    public static readonly SecurityLevel Public = new(0);
    public static readonly SecurityLevel Confidential = new(1);
    public static readonly SecurityLevel Secret = new(2);
    public static readonly SecurityLevel TopSecret = new(3);
    
    // Join operation (least upper bound) - use | operator
    public static SecurityLevel operator |(SecurityLevel a, SecurityLevel b)
        => new(Math.Max(a.Level, b.Level));
    
    // Meet operation (greatest lower bound) - use & operator
    public static SecurityLevel operator &(SecurityLevel a, SecurityLevel b)
        => new(Math.Min(a.Level, b.Level));
    
    public override string ToString() => Level switch
    {
        0 => "Public",
        1 => "Confidential",
        2 => "Secret",
        3 => "TopSecret",
        _ => $"Level({Level})"
    };
}

// Domain declaration
public static class SecurityDomain
{
    public static Type IndexType => typeof(SecurityLevel);
}

6.2 Classified Data Type

public struct Classified<TLevel>
    where TLevel : index SecurityDomain
{
    private readonly string _data;
    
    public Classified(string data)
    {
        _data = data;
    }
    
    // Combining data takes the join of security levels (using | operator)
    public static Classified<TResult> Combine<TLevel1, TLevel2, TResult>(
        Classified<TLevel1> a,
        Classified<TLevel2> b)
        where TLevel1 : index SecurityDomain
        where TLevel2 : index SecurityDomain
        where TResult : index SecurityDomain(TLevel1 | TLevel2)
    {
        return new Classified<TResult>(a._data + " " + b._data);
    }
    
    // Extract data (would need additional clearance checks in real system)
    public string GetData() => _data;
}

6.3 Usage Example

class InformationFlowExample
{
    public void ProcessClassifiedData()
    {
        var publicDoc = new Classified<SecurityLevel.Public>("Public info");
        var secretDoc = new Classified<SecurityLevel.Secret>("Secret info");
        
        // Combining takes the join (|) of security levels
        var combined = Classified.Combine(publicDoc, secretDoc);
        // Type: Classified<TResult>
        //   where TResult : index SecurityDomain(SecurityLevel(2))  // Secret
        
        var confidential1 = new Classified<SecurityLevel.Confidential>("Conf 1");
        var confidential2 = new Classified<SecurityLevel.Confidential>("Conf 2");
        
        var bothConfidential = Classified.Combine(confidential1, confidential2);
        // Type: Classified<TResult>
        //   where TResult : index SecurityDomain(SecurityLevel(1))  // Confidential
        
        // Compile-time error: can't assign Secret data to Public variable
        // Classified<SecurityLevel.Public> leak = secretDoc;
    }
}

7. Example: Effect System

7.1 Domain Definition

// Index type: effects form a semilattice
// Note: We use a readonly struct instead of a [Flags] enum because C# enums
// cannot have custom operators defined on them. The struct wraps a flags value
// and provides set operations as operators.
public readonly record struct Effect
{
    private Effect(int flags) => Flags = flags;
    
    public int Flags { get; }
    
    // Predefined effects
    public static readonly Effect Pure = new(0);
    public static readonly Effect IO = new(1);
    public static readonly Effect Exception = new(2);
    public static readonly Effect Async = new(4);
    public static readonly Effect Unsafe = new(8);
    
    // Union operation (join) - combines effects
    public static Effect operator |(Effect a, Effect b) 
        => new(a.Flags | b.Flags);
    
    // Intersection operation (meet)
    public static Effect operator &(Effect a, Effect b) 
        => new(a.Flags & b.Flags);
    
    public bool HasFlag(Effect e) => (Flags & e.Flags) == e.Flags;
    
    public override string ToString()
    {
        if (Flags == 0) return "Pure";
        var parts = new List<string>();
        if ((Flags & 1) != 0) parts.Add("IO");
        if ((Flags & 2) != 0) parts.Add("Exception");
        if ((Flags & 4) != 0) parts.Add("Async");
        if ((Flags & 8) != 0) parts.Add("Unsafe");
        return string.Join(" | ", parts);
    }
}

// Domain declaration
public static class EffectDomain
{
    public static Type IndexType => typeof(Effect);
}

7.2 Effectful Computation Type

public struct Computation<TEffect, TResult>
    where TEffect : index EffectDomain
{
    private readonly Func<TResult> _computation;
    
    public Computation(Func<TResult> computation)
    {
        _computation = computation;
    }
    
    // Run the computation
    public TResult Run() => _computation();
    
    // Sequencing combines effects
    public Computation<TResultEffect, TResult2> Then<TEffect2, TResultEffect, TResult2>(
        Func<TResult, Computation<TEffect2, TResult2>> next)
        where TEffect2 : index EffectDomain
        where TResultEffect : index EffectDomain(TEffect | TEffect2)
    {
        return new Computation<TResultEffect, TResult2>(() =>
        {
            var result = _computation();
            return next(result).Run();
        });
    }
    
    // Map preserves effects
    public Computation<TEffect, TResult2> Select<TResult2>(
        Func<TResult, TResult2> selector)
        where TEffect : index EffectDomain
    {
        return new Computation<TEffect, TResult2>(() =>
            selector(_computation())
        );
    }
}

7.3 Usage Example

class EffectSystemExample
{
    // Pure computation
    public Computation<Effect.Pure, int> PureAdd(int a, int b)
    {
        return new Computation<Effect.Pure, int>(() => a + b);
    }
    
    // IO computation
    public Computation<Effect.IO, string> ReadFile(string path)
    {
        return new Computation<Effect.IO, string>(() =>
            System.IO.File.ReadAllText(path)
        );
    }
    
    // Computation with multiple effects
    public Computation<TResult, int> ParseFileContent<TResult>(string path)
        where TResult : index EffectDomain(Effect.IO | Effect.Exception)
    {
        return ReadFile(path).Select(content => int.Parse(content));
    }
    
    public void EffectTracking()
    {
        var pure = PureAdd(1, 2);
        // Type: Computation<Effect(0), int>  // Pure
        
        var io = ReadFile("data.txt");
        // Type: Computation<Effect(1), string>  // IO
        
        var combined = pure.Then(result => 
            ReadFile("data.txt").Select(content => result + content.Length)
        );
        // Type: Computation<TResult, int>
        //   where TResult : index EffectDomain(Effect(0) | Effect(1))
        //   = Computation<Effect(1), int>  // IO (Pure | IO = IO)
    }
}

10. Compiler Implementation

10.1 Required Compiler Changes

The implementation requires modifications to several compiler phases:

• Parser extension to regcognize the index keyword and parse where clauses
• the (comple time) type system needs a new type constraint for index domain name and index expression
• the constraint checker need to resolve the domain, validate it and evaluate the expression by calling the domain operation
• code generator to emit code with index constraints erased

10.2 Error Messages

// Example errors:

error CS9901: Cannot apply operator '+' to operands of dimension 'Length' and 'Time'
  Types: Quantity<Length> and Quantity<Time>
    where Length : index DimensionDomain(Dimension(0,1,0))
    where Time : index DimensionDomain(Dimension(0,0,1))
  Dimensions are incompatible for addition

error CS9902: Cannot infer dimension for type parameter 'TResult'
  Constraint: where TResult : index DimensionDomain(TDim / Time)
  Unable to solve: TDim is not bound to a concrete dimension
  Consider adding an explicit type argument

error CS9903: Type 'MyDomain' cannot be used as a constraint domain
  Missing required member: 'public static Type IndexType { get; }'
  
error CS9904: Operation '*' is not defined on index type 'SecurityLevel'
  Index constraint: where TResult : index SecurityDomain(TLevel1 * TLevel2)
  Type 'SecurityLevel' does not define 'operator *(SecurityLevel, SecurityLevel)'

Appendix A: Normalization Example

Some index types require normalization to ensure equivalent values are recognized as equal during type unification. This appendix demonstrates a Fraction domain where normalization is essential.

A.1 The Problem

Consider a domain for tracking fractional scaling factors. Without normalization, Fraction(2, 4) and Fraction(1, 2) would be considered different types, even though they represent the same value:

var a = Scale<Fraction(1, 2)>(x);   // apply 1/2
var b = Scale<Fraction(1, 2)>(a);   // apply 1/2 again
// Result: Fraction(1, 4) from multiplication

var c = Scale<Fraction(2, 8)>(x);   // apply 2/8 directly
// Without normalize: Fraction(2, 8) ≠ Fraction(1, 4) — type error!

A.2 Domain Definition with Normalize

// Index type representing fractions
public record Fraction(int Numerator, int Denominator)
{
    public static Fraction operator *(Fraction a, Fraction b)
        => new(a.Numerator * b.Numerator, a.Denominator * b.Denominator);
    
    public static Fraction operator /(Fraction a, Fraction b)
        => new(a.Numerator * b.Denominator, a.Denominator * b.Numerator);
    
    // REQUIRED: Normalize to canonical form for equality
    public Fraction Normalize()
    {
        var gcd = GCD(Math.Abs(Numerator), Math.Abs(Denominator));
        var sign = Denominator < 0 ? -1 : 1;
        return new Fraction(sign * Numerator / gcd, sign * Denominator / gcd);
    }
    
    private static int GCD(int a, int b) => b == 0 ? a : GCD(b, a % b);
    
    public static Fraction Identity => new(1, 1);
}

public static class FractionDomain
{
    public static Type IndexType => typeof(Fraction);
}

public static class Fractions
{
    public static readonly Fraction Half = new(1, 2);
    public static readonly Fraction Third = new(1, 3);
    public static readonly Fraction Quarter = new(1, 4);
}

A.3 Constraint Solving with Normalization

To solve: TResult where TResult : index FractionDomain(Half * Half)
where Half = Fraction(1, 2)

• Step 1: Load Fraction values
  • Half = Fraction(1, 2)
• Step 2: Invoke Fraction.operator *(Half, Half)
  • Result = Fraction(1, 4)
• Step 3: Normalize result
  • Fraction(1, 4).Normalize() = Fraction(1, 4) (already reduced)
• Step 4: Bind TResult := Fraction(1, 4)

Another example showing normalization in action:

To solve: TResult where TResult : index FractionDomain(TwoFourths * Half)
where TwoFourths = Fraction(2, 4) and Half = Fraction(1, 2)

• Step 1: Load Fraction values
  • TwoFourths = Fraction(2, 4)
  • Half = Fraction(1, 2)
• Step 2: Invoke Fraction.operator *(TwoFourths, Half)
  • Result = Fraction(2, 8)
• Step 3: Normalize result
  • Fraction(2, 8).Normalize() = Fraction(1, 4)
• Step 4: Bind TResult := Fraction(1, 4)

With normalization, both Fraction(1,2) * Fraction(1,2) and Fraction(2,4) * Fraction(1,2) resolve to the same canonical form Fraction(1, 4), enabling correct type unification.

A.4 Usage Example

public struct Scaled<TFactor>
    where TFactor : index FractionDomain
{
    public double Value { get; init; }
    
    public static Scaled<TResult> operator *(
        Scaled<TFactor1> a,
        Scaled<TFactor2> b)
        where TFactor1 : index FractionDomain
        where TFactor2 : index FractionDomain
        where TResult : index FractionDomain(TFactor1 * TFactor2)
    {
        return new Scaled<TResult> { Value = a.Value * b.Value };
    }
}

class ScalingExample
{
    public void FractionScaling()
    {
        var half = new Scaled<Fractions.Half> { Value = 10.0 };
        var quarter = half * half;  // Scaled<Fraction(1, 4)>
        
        // These two have the same type after normalization:
        var viaMultiply = half * half;           // Fraction(1,2) * Fraction(1,2) → Fraction(1,4)
        var direct = new Scaled<Fractions.Quarter> { Value = 25.0 };
        
        // Can be used together because types unify
        // var sum = viaMultiply + direct;  // Works!
    }
}

References

1. Kennedy, Andrew J. Dimension Types. PhD thesis, University of Cambridge, 1996.
   https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-391.pdf

2. Kennedy, Andrew. "Types for Units-of-Measure: Theory and Practice." Central European Functional Programming School (CEFP 2009), Lecture Notes in Computer Science, vol. 6299, Springer, 2010.
   https://link.springer.com/chapter/10.1007/978-3-642-17685-2_8

3. Scala 3 Documentation. "Opaque Type Aliases."
   https://docs.scala-lang.org/scala3/book/types-opaque-types.html

   Note: Scala 3's opaque types provide zero-cost type distinctions but without algebraic operations on indices. They prevent mixing of types but don't support computing result types from operations (e.g., Length / Time → Velocity).

[HaloFour]

I know units of measure have come up a couple of different times but I don't see a single discussion used as the source of truth. Most point back to "roles" as being a solution:

#5496

[xtofs]

My understanding is that doing this with roles is un-ergonomic. Roles don’t compose easily and in the units-of-measure example this means one needs to explicitly name roles for every combination of base units.
but the proposal is not primarily about units of measure and not an alternative to roles. It’s about index types and their relationship.

[TahirAhmadov]

For physical measurements, it's trivial to put together struct wrappers which satisfy all of the requirements: ensuring that values of different units don't intermingle, applicable operations (like distance divided by time equals speed, etc.); I fail to see how a language feature is needed at all for them.

[CyrusNajmabadi]

The combinations that your program might produce as you multiply or divide values is practically infinite.

While i agree that technically an infinite number of combinations are possible. I think the question is if in practice, it's actually quite finite, and not expensive to hand write.

Furthermore, it seems totally viable to have a source-gen exist to see if a new type needs to be generated.

[xtofs]

it would be allowed and you'd get m^6, which is not useful.

Sometimes it is https://en.wikipedia.org/wiki/Van_der_Waals_equation

[TahirAhmadov]

There are three different methods of calculating angular momentum;

struct Mass
{
  double Value; // kg
}
struct Length
{
  public static Velocityoperator/(Length left, TimeSpan right) => new(left.Value / right.TotalSeconds);
  double Value; // m
}
struct Velocity
{
  public static LinearMomentum operator*(Velocity left, Mass right) => new(left.Value * right.Value);
  double Value; // m/s
}
struct LinearMomentum
{
  public static AngularMomentum operator*(LinearMomentum left, Length right) => new(left.Value * right.Value);
  double Value; // kg*m/s
}
struct AngularMomentum 
{
  double Value; // kg*m^2/s
}
Velocity v = ...;
Mass m = ...;
Length positionVector = ...;
var angularMomentum = v * m * positionVector;
var linearMomentum = v * m;
var angularMomentum2 = linearMomentum * positionVector;
// etc.

I mean yes, you have to write out the types and operators, but that's what source generators and Nuget are for.

[Richiban]

How exactly would you source-generate this? How would you indicate to a source generator that multiplying Mass and Velocity gives LinearMomentum? Or that dividing Length by a TimeSpan gives a Velocity?

[TahirAhmadov]

Those operations would have to be written by the developer, of course. I meant the SG can help with the boilerplate - equality, serialization, etc.
For new project development, I would start with UnitsNet library linked above, and enhance it as needed. I haven't reviewed it in detail; I think I would do unit conversions differently than they did; but it's a start. Most importantly, it's already available.

[xtofs]

Typed Stages for Flexbox Layout Pipeline

This example uses indexed types to model a multi-stage computation where each stage unlocks additional fields. The domain is a flexbox layout pipeline, but the pattern generalises to any computation where values are progressively enriched and you want the compiler to enforce ordering.

Pipeline Functions

Each step is a pure function that advances the stage. Return types are concrete float, not Nullable<float> — the stage index carries the invariant that the field is populated.

static LayoutItem<Stage.Distributed> ResolveBasis(
    LayoutItem<Stage.Basis> item)
    => item with { MainSize = item.Original.FlexBasis ?? item.Original.IntrinsicMain };

static LayoutItem<Stage.Distributed> Distribute(
    LayoutItem<Stage.Distributed> item, float delta)
    => item with { MainSize = item.MainSize + delta };

static LayoutItem<Stage.MainPos> AssignMainPos(
    LayoutItem<Stage.Distributed> item, float offset)
    => new()
    {
        Original  = item.Original,
        MainSize  = item.MainSize,
        MainPos   = offset,
        CrossSize = item.Original.IntrinsicCross,
        CrossPos  = 0f
    };

static LayoutItem<Stage.CrossPos> AssignCrossPos(
    LayoutItem<Stage.MainPos> item, float offset, float crossSize)
    => new()
    {
        Original  = item.Original,
        MainSize  = item.MainSize,
        MainPos   = item.MainPos,
        CrossSize = crossSize,
        CrossPos  = offset
    };

The Stage Domain

Stages form a totally ordered set. The join operation (|) gives the maximum of two stages, which lets us express “at least this stage” as a constraint.

public record Stage(int Order)
{
    public static readonly Stage Basis       = new(0);
    public static readonly Stage Distributed = new(1);
    public static readonly Stage MainPos     = new(2);
    public static readonly Stage CrossPos    = new(3);

    // join: maximum of two stages
    public static Stage operator |(Stage a, Stage b) => new(Math.Max(a.Order, b.Order));
}

public static class StageDomain
{
    public static Type IndexType => typeof(Stage);
}

The Item Type

A single struct carries all fields. The stage index is erased at codegen — zero runtime overhead.

public struct LayoutItem<TStage>
    where TStage : index StageDomain
{
    public Item   Original  { get; init; }
    public float  MainSize  { get; init; }  // available from Basis
    public float  MainPos   { get; init; }  // available from MainPos
    public float  CrossSize { get; init; }  // available from CrossPos
    public float  CrossPos  { get; init; }  // available from CrossPos
}

What the Compiler Enforces

Calling a function with an item at the wrong stage is a compile error:

// Error: AssignMainPos expects Stage.Distributed, not Stage.Basis
var wrong = AssignMainPos(rawItem, 0f);

Polymorphism Over Stages

A function that requires a minimum stage uses the join constraint. Stage.MainPos | TStage evaluates to TStage only when TStage ≥ Stage.MainPos, so the compiler accepts MainPos and CrossPos items but rejects earlier stages:

static float GetMainPos<TStage>(LayoutItem<TStage> item)
    where TStage : index StageDomain(Stage.MainPos | TStage)
    => item.MainPos;

Why This Matters

Two properties follow from the stage index that cannot be expressed with plain generics or Nullable<float> fields:

• Impossible states are unrepresentable at the function boundary. MainPos is a float at every stage where it exists. There is no null to handle downstream and no runtime null check needed — the guarantee that the field is populated is expressed entirely in the type, not in documentation or convention.
• The pipeline order is enforced structurally. The type signatures form a chain. Skipping a step or calling steps out of order is rejected by the compiler, not discovered at runtime.

Limitation: the enforcement above operates at the level of function signatures, not field access. The proposal has no mechanism (yet) to make a field conditionally absent based on the index value. LayoutItem<Stage.Basis> and LayoutItem<Stage.CrossPos> are the same struct with the same fields at runtime — nothing prevents directly reading MainPos off a Basis-stage item outside of the pipeline functions. Full field-level enforcement would require an additional language feature .

[TahirAhmadov]

Can you demonstrate a real world example of using this approach?

[colejohnson66]

Is that not just "linear types", but less useful?

[chrisspre]

Can you demonstrate a real world example of using this approach?

This is a type system update proposal and about ways to model data. Is the flex box layout pipeline not real world?

[chrisspre]

Is that not just "linear types", but less useful?

Linear types ensure that objects are used exactly once. This proposal is related to dependent types and intentionally less powerful to make it feasible in C#