除C++外的类型化语言能否实现泛型类型的泛型工厂及转换器？

需求说明 #

我们需要实现这样的功能：定义一个泛型类型D<G<T>>（其中G是泛型容器类型，T是其元素类型），该类型的方法能接收处理器函数，返回同一泛型容器G的不同特化版本G<O>。以下是示例C++代码，展示核心逻辑：

#include <print>

template<typename D>
struct data_container {
    D content;
};

template<template<typename> class S, typename T>
class data_transformer {
    S<T> data;

    public:
    data_transformer(S<T> data) : data{data} {}

    auto transform(auto handler) {
        return S{handler(data)};
    };
};

auto convert_to_string = [](auto it){ return std::to_string( it.content ); };

int main() {
    auto data = data_container { 42 };
    // data is a data_container<int>

    auto transformer = data_transformer { data };

    auto result = transformer.transform (convert_to_string);
    // result is a data_container<std::string>

    std::println( "{}", result.content + "!" );
}

除C++外，不少静态类型语言支持这类高阶泛型场景，以下是几种常见语言的实现方案：

Rust #

Rust通过高阶泛型约束和trait系统，可优雅实现该功能：

use std::fmt::Display;

// 泛型容器
#[derive(Debug)]
struct DataContainer<D> {
    content: D,
}

// 定义trait，抽象泛型容器的构造逻辑
trait FromElement<A> {
    fn from_element(a: A) -> Self;
}

// 为DataContainer实现构造trait
impl<D> FromElement<D> for DataContainer<D> {
    fn from_element(a: D) -> Self {
        DataContainer { content: a }
    }
}

// 泛型转换器：S是泛型容器类型，T是初始元素类型
struct DataTransformer<S, T>
where
    S: FromElement<T>,
{
    data: S,
}

impl<S, T> DataTransformer<S, T>
where
    S: FromElement<T>,
{
    fn new(data: S) -> Self {
        Self { data }
    }

    // transform方法：接收处理器，返回同一泛型容器的不同特化版本
    fn transform<O, F>(self, handler: F) -> impl FromElement<O>
    where
        F: FnOnce(S) -> O,
    {
        FromElement::from_element(handler(self.data))
    }
}

// 处理器函数：把DataContainer<i32>转为String
fn convert_to_string(container: DataContainer<i32>) -> String {
    container.content.to_string()
}

fn main() {
    let data = DataContainer { content: 42 };
    // data 是 DataContainer<i32>

    let transformer = DataTransformer::new(data);
    let result = transformer.transform(convert_to_string);
    // result 是 DataContainer<String>

    println!("{}!", result.content);
}

Rust的trait系统可灵活抽象泛型容器的构造逻辑，高阶泛型约束让DataTransformer能适配任意满足条件的泛型容器。

Scala #

Scala原生支持泛型类型构造器（用S[_]表示单参数泛型类型），结合implicit机制可实现类似C++的模板模板参数效果：

// 泛型容器
case class DataContainer[D](content: D)

// 定义implicit trait，抽象泛型容器的构造能力
trait ContainerBuilder[F[_]] {
  def build[A](value: A): F[A]
}

// 为DataContainer实现构造器
object ContainerBuilder {
  implicit val dataContainerBuilder: ContainerBuilder[DataContainer] =
    new ContainerBuilder[DataContainer] {
      def build[A](value: A): DataContainer[A] = DataContainer(value)
    }
}

// 泛型转换器：S[_]是泛型容器构造器，T是初始元素类型
class DataTransformer[S[_], T](data: S[T])(implicit builder: ContainerBuilder[S]) {
  // transform方法：返回同一泛型容器的不同特化版本
  def transform[O](handler: S[T] => O): S[O] = {
    builder.build(handler(data))
  }
}

object Main extends App {
  val data = DataContainer(42)
  // data 是 DataContainer[Int]

  val transformer = new DataTransformer(data)
  val convertToString = (container: DataContainer[Int]) => container.content.toString
  val result = transformer.transform(convertToString)
  // result 是 DataContainer[String]

  println(s"${result.content}!")
}

Scala的S[_]语法直接指代“单参数泛型类型”，implicit构造器避免了硬编码容器类型，让转换器具备通用性。

C# #

C#没有直接的模板模板参数，但可通过工厂委托实现高效的类似功能：

using System;

// 泛型容器
public class DataContainer<D>
{
    public D Content { get; }
    public DataContainer(D content) => Content = content;
}

// 泛型转换器：接收泛型容器实例，以及对应的工厂委托
public class DataTransformer<S, T>
    where S : DataContainer<T>
{
    private readonly S _data;
    private readonly Func<object, object> _containerFactory;

    public DataTransformer(S data, Func<object, object> containerFactory)
    {
        _data = data;
        _containerFactory = containerFactory;
    }

    // transform方法：返回同一泛型容器的不同特化版本
    public DataContainer<O> Transform<O>(Func<S, O> handler)
    {
        var outputValue = handler(_data);
        return _containerFactory(outputValue) as DataContainer<O>;
    }
}

class Program
{
    static void Main()
    {
        var data = new DataContainer<int>(42);
        // data 是 DataContainer<int>

        // 传入DataContainer的工厂委托：把任意值转为对应泛型容器
        var transformer = new DataTransformer<DataContainer<int>, int>(
            data, 
            val => new DataContainer<object>(val)
        );

        // 处理器函数
        string ConvertToString(DataContainer<int> container)
        {
            return container.Content.ToString();
        }

        var result = transformer.Transform(ConvertToString);
        // result 是 DataContainer<string>

        Console.WriteLine($"{result.Content}!");
    }
}

C#通过工厂委托规避了反射的性能问题，同时保证了转换器对泛型容器的通用性。

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