TypeScript的所谓Type弄得这么变态么？

Sly

type Minus1<T extends number, C extends any[] = []> = [
  1,
  ...C
]["length"] extends T
  ? C["length"]
  : [1, 1, ...C]["length"] extends T
  ? [1, ...C]["length"]
  : Minus1<T, [1, 1, ...C]>;

type Number0= Minus1<1>

这么变态的且不谈，有人真的会用到所谓体操么？

xy.

这个是 dependent type, 在类型系统中不算复杂的. 只是看起来长.

xy.

给你翻译成 cpp 看起来就比较简洁了

1. #include <concepts>
   
2. 
   
3. using Zero = struct {};
   
4. 
   
5. template<typename>
   
6. struct Succ {};
   
7. 
   
8. template<auto x>
   
9. auto NatConstructor() {
   
10.     if constexpr (x == 0)
    
11.         return Zero{};
    
12.     else
    
13.         return Succ<decltype(NatConstructor<x - 1>())>{};
    
14. }
    
15. 
    
16. template<auto x>
    
17. using Nat = decltype(NatConstructor<x>());
    
18. 
    
19. auto main()->int {
    
20.     using One = Succ<Zero>;
    
21.     using Two = Succ<Succ<Zero>>;
    
22.     using Three = Succ<Succ<Succ<Zero>>>;
    
23. 
    
24.     using x = Nat<1>;
    
25.     using y = Nat<2>;
    
26.     using z = Nat<3>;
    
27.     using w = Nat<0>;
    
28. 
    
29.     static_assert(std::same_as<w, Zero>);
    
30.     static_assert(std::same_as<x, One>);
    
31.     static_assert(std::same_as<y, Two>);
    
32.     static_assert(std::same_as<z, Three>);
    
33. }

复制代码

andyaldi

还好吧，最近我们公司新上的项目都开始放弃ts了。维护起来，成本太高了，尤其是一帮二把刀的后端，返回的同一个field name，经常出现不同的类型，疯了，想咋写就咋写。