强类型语言中sum-type数据的无重复case映射实现方案问询

在处理大型Sum Type（如F#的Discriminated Union）时，实现值的函数映射常遇到两个痛点：

1. 手动编写模式匹配分支时，需重复写出每个case的构造函数，代码冗余且易出错；
2. 若误返回错误case，类型检查器可能无法及时捕获问题。

以下是F#及其他支持Sum Type语言的解决方案：

F# 解决方案 #

改进版反射方案（更安全） #

你提供的反射方案可优化，避免通过ToString()匹配case，直接利用FSharpValue.GetUnionFields获取的case信息，降低运行时风险：

open FSharp.Reflection

type MyData =
    | Foo of int
    | Bar of bool
    | Baz of string
    | Hello of int

module MyData =
    let map (f:int->int) (g:bool->bool) (h:string->string) (x:MyData) =
        let case, args = FSharpValue.GetUnionFields(x, typeof<MyData>)
        let newArg =
            match case.Name with
            | "Foo" | "Hello" -> box (f (args.[0] :?> int))
            | "Bar" -> box (g (args.[0] :?> bool))
            | "Baz" -> box (h (args.[0] :?> string))
            | _ -> failwithf "未知case: %s" case.Name
        FSharpValue.MakeUnion(case, [| newArg |]) :?> MyData

// 使用示例
let mapMyData = MyData.map ((+) 1) not (fun s -> s.ToUpper())
let newFoo = mapMyData (Foo 42)
let newBar = mapMyData (Bar true)

此方案仅需在match case.Name分支中指定函数，无需重复写构造函数，减少冗余。

代码生成/Type Provider方案 #

对于超大型DU，可借助F#的Type Provider或dotnet fsi脚本自动生成map函数。脚本可遍历DU元数据，自动输出完整的模式匹配代码，确保每个case的映射逻辑正确，且类型检查器能完全验证。

Haskell 解决方案 #

通过generics-sop库，基于Generic类型类实现类型安全的自动映射：

{-# LANGUAGE DeriveGeneric #-}
import Generics.SOP

data MyData = Foo Int | Bar Bool | Baz String | Hello Int deriving (Generic, Show)

instance Generic MyData

mapMyData :: (Int -> Int) -> (Bool -> Bool) -> (String -> String) -> MyData -> MyData
mapMyData f g h = to . hcollapse . zipWith applyHandler handlers . from
  where
    handlers = NP.fromList [K (Foo . f), K (Bar . g), K (Baz . h), K (Hello . f)]
    applyHandler (K h) (I x) = K (h x)

from将Sum Type转换为SOP（Sum of Products）形式，zipWith匹配每个分支的处理函数，最后通过to转换回原类型。若处理超大型类型，可结合Template Haskell自动生成handlers列表。

PureScript 解决方案 #

利用generic-rep库提供的Generic映射能力：

import Data.Generic.Rep (class Generic, from, to)
import Data.Tuple (Tuple1(..))

data MyData = Foo Int | Bar Boolean | Baz String | Hello Int deriving (Generic, Show)

mapMyData :: (Int -> Int) -> (Boolean -> Boolean) -> (String -> String) -> MyData -> MyData
mapMyData f g h = to <<< zipWith applyHandler handlers <<< from
  where
    handlers = [Foo <<< f, Bar <<< g, Baz <<< h, Hello <<< f]
    applyHandler h (Tuple1 x) = h x

通过from将类型转换为通用表示，处理后再通过to还原，避免手动编写所有模式匹配分支。

Idris 解决方案 #

结合Generic接口与依赖类型，确保映射逻辑的类型安全：

import Data.Generic

data MyData = Foo Int | Bar Bool | Baz String | Hello Int deriving Generic

mapMyData : (Int -> Int) -> (Bool -> Bool) -> (String -> String) -> MyData -> MyData
mapMyData f g h = genericMap (\case
  "Foo" => f
  "Bar" => g
  "Baz" => h
  "Hello" => f)

若需更严格的类型保障，可定义依赖类型描述每个case的关联类型，确保函数与case类型完全匹配，避免运行时错误。

Rust 解决方案 #

Rust的枚举作为Sum Type，可通过自定义Derive宏自动生成map函数，避免手动编写冗余分支：

1. 编写自定义Derive宏（依赖syn和quote） #

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(Map)]
pub fn derive_map(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    let variants = match &input.data {
        syn::Data::Enum(data) => &data.variants,
        _ => panic!("Map仅支持枚举类型"),
    };

    let arms = variants.iter().map(|variant| {
        let var_name = &variant.ident;
        let field = &variant.fields.iter().next().unwrap();
        let fn_name = match &field.ty {
            syn::Type::Path(path) => match path.path.segments.last().unwrap().ident.to_string().as_str() {
                "i32" => "f",
                "bool" => "g",
                "String" => "h",
                _ => panic!("不支持的字段类型"),
            },
            _ => panic!("不支持的字段类型"),
        };
        quote! {
            #name::#var_name(val) => #name::#var_name(#fn_name(val)),
        }
    });

    let expanded = quote! {
        impl #name {
            pub fn map<F, G, H>(self, f: F, g: G, h: H) -> Self
            where
                F: Fn(i32) -> i32,
                G: Fn(bool) -> bool,
                H: Fn(String) -> String,
            {
                match self {
                    #(#arms)*
                }
            }
        }
    };

    TokenStream::from(expanded)
}

2. 使用宏生成map函数 #

#[derive(Map)]
enum MyData {
    Foo(i32),
    Bar(bool),
    Baz(String),
    Hello(i32),
}

// 使用示例
fn main() {
    let foo = MyData::Foo(42);
    let new_foo = foo.map(|x| x + 1, |b| !b, |s| s.to_uppercase());
}

自定义宏会自动生成完整的map函数，类型检查器会验证所有分支的正确性，避免手动编写冗余代码。

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