哪些编译型编程语言可实现透明计算式鸭子类型？

需求背景 #

需要的是支持以下特性的编译型语言：

1. 鸭子类型函数：函数能自动从传入的结构中查找指定名称的成员，无需显式继承接口；
2. 透明计算成员：计算型成员（由其他成员推导而来）的使用语法与普通存储成员完全一致，修改字段为计算/存储类型时，调用代码无需改动。

对应的伪代码示例：

基础鸭子类型实现 #

my_structure = {
    value_a: integer,
    value_b: integer,
}

duck_typed_function(
    ducktyped value_a,
    ducktyped value_b)
{
    return value_a + value_b;
}

my_structure instance = { 1, 2 };
result = duck_typed_function(instance);

透明计算成员扩展 #

my_structure = {
    value_a: integer,
    value_b: integer,
    value_c: integer => value_a + value_b, // 计算成员定义
}

computed_duck_typed_function(
    ducktyped value_c)
{
    return value_c * 2; // 与普通成员调用语法完全一致
}

my_structure instance = { 1, 2, }; // 无需初始化计算成员
result = computed_duck_typed_function(instance);

可实现的编译型语言 #

以下语言可以满足上述需求：

1. C++ #

• 鸭子类型实现：通过C++20的**概念（Concepts）**或SFINAE技术，在模板函数中检查类型是否包含指定成员；
• 透明计算成员：利用GCC/Clang的__attribute__((property))扩展，将成员函数伪装成成员变量，调用语法与普通成员完全一致；也可以用C++20的constexpr内联函数配合模板统一处理。
• 示例片段：

  struct MyStructure {
      int value_a;
      int value_b;
  
      // 计算成员，调用时直接用instance.value_c
      int get_value_c() const { return value_a + value_b; }
      int value_c __attribute__((property(get = get_value_c)));
  };
  
  // 鸭子类型函数，用Concept检查成员存在
  template<typename T>
  requires requires(T t) { t.value_c; }
  int computed_duck_typed_function(const T& t) {
      return t.value_c * 2;
  }
  

• 切换value_c为普通成员时，只需替换为int value_c;，调用代码无需修改。

2. D语言 #

• 鸭子类型实现：通过模板配合__traits(hasMember)编译期检查，判断类型是否包含指定成员；
• 透明计算成员：原生支持@property装饰器，将函数转换为属性，调用语法与存储成员完全一致。
• 示例片段：

  struct MyStructure {
      int value_a;
      int value_b;
  
      // 计算属性，调用时直接用instance.value_c
      @property int value_c() { return value_a + value_b; }
  }
  
  // 鸭子类型函数，编译期检查成员存在
  auto computedDuckTypedFunction(T)(T instance) if (__traits(hasMember, T, "value_c")) {
      return instance.value_c * 2;
  }
  

• 切换计算属性为存储成员时，只需替换为int value_c;，所有调用代码无需改动。

3. Swift #

• 鸭子类型实现：通过**协议（Protocol）**定义成员约束，类型自动遵循协议后即可传入函数；
• 透明计算成员：原生支持计算属性，语法与存储属性完全一致，还可实现反计算的setter逻辑。
• 示例片段：

  struct MyStructure {
      var value_a: Int
      var value_b: Int
  
      // 计算属性，支持get和反计算set
      var value_c: Int {
          get { value_a + value_b }
          set { value_a = newValue - value_b }
      }
  }
  
  // 定义鸭子类型协议
  protocol HasValueC {
      var value_c: Int { get }
  }
  
  extension MyStructure: HasValueC {}
  
  // 鸭子类型函数
  func computedDuckTypedFunction<T: HasValueC>(_ instance: T) -> Int {
      instance.value_c * 2
  }
  

• 切换计算属性为存储属性时，只需替换为var value_c: Int，调用代码无需修改。

4. Rust #

• 鸭子类型实现：通过Trait定义接口，类型实现Trait后即可传入函数；
• 透明计算成员：通过Trait方法统一封装存储成员和计算成员的访问逻辑，切换时只需修改Trait实现，调用代码无需改动。
• 示例片段：

  // 定义鸭子类型Trait
  trait HasValueC {
      fn value_c(&self) -> i32;
  }
  
  struct MyStructure {
      value_a: i32,
      value_b: i32,
  }
  
  // 计算成员的Trait实现
  impl HasValueC for MyStructure {
      fn value_c(&self) -> i32 {
          self.value_a + self.value_b
      }
  }
  
  // 切换为存储成员时，修改结构体和Trait实现：
  // struct MyStructure {
  //     value_a: i32,
  //     value_b: i32,
  //     value_c: i32,
  // }
  // impl HasValueC for MyStructure {
  //     fn value_c(&self) -> i32 { self.value_c }
  // }
  
  // 鸭子类型函数
  fn computed_duck_typed_function<T: HasValueC>(instance: &T) -> i32 {
      instance.value_c() * 2
  }
  

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