如何创建仅表示特定数字子集的受限Int类型数据结构？

Great question! 坚持“让不可能的状态无法被表示”绝对是个好习惯——这正是静态类型系统能发挥最大价值的地方。你提到的枚举方案虽然能实现需求，但范围稍大就会变得繁琐，确实不够优雅。下面是几种更具扩展性的方案，适配不同的编程语言场景：

1. 智能构造函数（Smart Constructor）：通用且易实现 #

这是函数式编程里的经典思路，核心是把类型的构造逻辑私有化，只暴露经过验证的创建入口，既限制了非法值的创建，又不用枚举每个有效值。

以TypeScript为例：

// 用品牌类型标记，防止普通number直接赋值
type MoonPhaseDay = number & { __moonPhaseDayBrand: never };

// 唯一的创建入口，运行时验证+编译时类型约束
function createMoonPhaseDay(value: number): MoonPhaseDay {
  if (value < 0 || value > 29) {
    throw new Error(`无效的月相日期：${value}，必须在0-29之间`);
  }
  // 类型断言把合法值转为受限类型
  return value as MoonPhaseDay;
}

// 正确用法：通过构造函数创建，类型安全
const waxingGibous = createMoonPhaseDay(15);
// 编译错误：普通number无法直接赋值给MoonPhaseDay
// const invalidDay: MoonPhaseDay = 30;
// 运行时错误：传入非法值会抛出异常
// const badDay = createMoonPhaseDay(30);

这种方案的优点是几乎所有静态类型语言都能实现（比如Java的私有构造+静态工厂方法、Scala的伴生对象工厂），扩展性拉满——哪怕你把范围改成0-999，只需要修改工厂函数里的判断条件就行。

2. 依赖类型/Const泛型：编译时强制校验 #

如果你的语言支持依赖类型（比如Idris、Agda）或者const泛型（比如Rust、TypeScript 5.0+），可以做到完全在编译时拦截非法值，连运行时检查都能省掉。

以Rust为例：

// 用const泛型定义类型，通过where子句限制范围
struct MoonPhaseDay<const N: u8>;

// 只允许N在0-29之间的实例化
impl<const N: u8> MoonPhaseDay<N> where N <= 29 {
    pub fn new() -> Self {
        MoonPhaseDay
    }
}

fn main() {
    // 编译通过：合法值
    let day10 = MoonPhaseDay::<10>::new();
    // 编译错误！编译器会直接提示N超出范围
    // let day30 = MoonPhaseDay::<30>::new();
}

这种方案完美契合你的需求：编译器直接拒绝非法值，没有运行时开销，而且范围调整只需要修改where子句的条件，扩展性极强。

3. TypeScript递归范围类型：纯编译时校验 #

如果你用TypeScript，可以结合递归条件类型自动生成范围类型，避免手动枚举每个值：

// 递归类型生成指定区间的数字联合类型
type Range<Start extends number, End extends number, Acc extends number[] = []> =
  Acc['length'] extends End ? [...Acc, End][number] :
  Acc['length'] extends Start ? Range<Start, End, [...Acc, Start]> :
  Range<Start, End, [...Acc, Acc['length']]>;

// 生成0-29的受限类型
type MoonPhaseDay = Range<0, 29>;

// 正确用法
const validDay: MoonPhaseDay = 15;
// 编译错误：Type '30' is not assignable to type 'MoonPhaseDay'
const invalidDay: MoonPhaseDay = 30;

这种方案完全在编译时生效，不需要任何运行时代码，调整范围只需要修改Range的参数即可，比手动枚举优雅太多。

对比与总结 #

• 枚举方案：适合极小范围（比如0-5），但范围扩大后代码量爆炸，扩展性差。
• 智能构造函数：通用型最强，适配绝大多数语言，兼顾编译时类型约束和运行时兜底。
• 依赖类型/Const泛型：最极致的类型安全，编译时完全拦截非法值，适合支持这类特性的语言。
• TypeScript递归范围类型：纯编译时校验，无需运行时代码，适合TS场景。

核心思路都是通过封装或类型约束，确保只有合法值能被构造为目标类型，完美践行“让不可能的状态无法被表示”的原则。

内容的提问来源于stack exchange，提问作者Eroc