F# 是否可以识别 DU 的重叠并使用正确的重叠本身？

Question

type GenericResult =
    | Ok
    | Error of string

type LoginResult =
    | Ok
    | UserNotFound
    | WrongPassword

let check something:GenericResult =
    match something with
    //| true -> Ok // error:This expression was expected to be of type "GenericREsult" but here has type "LoginResult"
    | true -> GenericResult.Ok // I'm forced to specify GenericResult.Ok
    | false -> Error "aargg!"

let checkLogin something:LoginResult =
    match something with
    | true -> Ok // here I don't need to specify the DU because this is defined after
    | _ -> WrongPassword

我想在这两种方法中只使用“Ok”，而不需要指定 DU。
我发现，如果值发生冲突，最后一个是“预定义的”。

理想情况下，我希望拥有某种继承权
在另一个 DU 中重用一个 DU 的一部分。
例如：

type GenericResult =
    | Ok
    | Error of string

type LoginResult =
    //| GenericResult.Ok
    | UserNotFound
    | WrongPassword

type SaveResult =
    | Created
    | Updated
    //| GenericResult.Error


let checkLogin something: LoginResult | GenericResult.Ok =
    match something with
    | true -> Ok 
    | _ -> WrongPassword

[编辑] 我觉得需要此功能的真实场景是来自 3 个不同逻辑类的 3 个不同结果。
将来会出现更多情况，因此重复 DU 值的倍数将会增加。

// DUs ordered from the most specific to the most generic

type BalanceUpdateResult = 
| Created
| Updated
| InvalidRequest of string

type DeleteResult =
| Ok
| InvalidRequest of string

type Result<'T> =
| Ok of 'T
| NotValid of string
| Error of string

目标是在使用者中拥有干净的匹配语法，例如，DU 的值最终将用于引发异常或返回创建的值。

// balance update function (result is BalanceUpdateResult):
    match result with
    | Created -> this.createOkWithStatus 201 
    | Updated -> this.createOkWithStatus 200
    | InvalidRequest error -> this.createErrorForConflict error

// company creation function (result is Result<Company>):
    match result with 
    | Result.Ok newItem -> 
        context.Logger.Log $"Company created. New Id:{newItem.Id}, Name:{newItem.Name}."
        this.createCreated newItem
    | NotValid error -> base.createErrorForConflict error
    | Error error -> base.createError error

例如，在第二种情况下，InvalidRequest 不被接受，因为它属于错误的 DU。
必须在各处指定 DU 会导致混乱，如下例所示（请参阅许多结果<_>。）：

    interface ICompanyLogic with
        member this.Create(company:Company):Result<Company> =
            match normalize company |> validate with
            | NotValid msg -> Result<_>.NotValid msg
            | Valid validCompany ->
                match companyRepository.Exists(validCompany.Name) with 
                | true -> Result<_>.NotValid($"A company with name \"{validCompany.Name}\" already exists.")
                | _ -> 
                    let newCompany = assignNewId validCompany
                    companyRepository.Create(newCompany)
                    Result<_>.Ok(newCompany)
            
        member this.Update (company:Company):Result<Company> =
            let checkNameExists company = 
                match companyRepository.GetByName company.Name with
                | Some c when c.Id <> company.Id -> NotValid $"A company with name \"{company.Name}\" already exists."
                | _ -> Valid company
         
            match normalize company |> validate with
            | NotValid msg -> Result<_>.NotValid msg
            | Valid c -> match checkNameExists c with
                         | Valid c -> companyRepository.Update c; Result<_>.Ok c
                         | NotValid msg -> Result<_>.NotValid msg
            

Answer 1

我认为实现您想要做的事情的最佳方法是从通用 Result 类型开始，该类型具有表示错误类型的类型参数：

type Result<'TError> =
    | Ok
    | Error of 'TError

这允许您使用不同的类型来表示错误，包括 string，还有另一个 DU 来捕获更具体的错误类型。然后，您可以将 GenericResult 和 LoginResult 定义为两个类型别名：

type LoginError =
    | UserNotFound
    | WrongPassword

type GenericResult = Result<string>
type LoginResult = Result<LoginError>

要报告登录错误，您现在可以使用 Error WrongPassword 来包装特定错误在通用 Error 构造函数中。这两个函数的实现如下所示：

let check something:GenericResult =
  match something with
  | true -> Ok
  | false -> Error "aargg!"

let checkLogin something:LoginResult =
  match something with
  | true -> Ok
  | _ -> Error WrongPassword

Answer 2

与 TypeScript 联合类型不同，F# DU 旨在组合且不可扩展 - 请参阅 Thomas 答案 了解使用此方法的解决方案。

由于 F# 不提供直接的解决方案，您可以考虑重命名诸如 InvalidRequest 之类的情况，以便更具体并帮助在阅读代码时区分它们。使用这些特定名称，您还可以将所有结果类型合并到一个大的 Event DU 中，就像在事件源系统中通常所做的那样：

type Event = 
// BalanceUpdateResult
| BalanceCreated
| BalanceUpdated
| BalanceUpdateError of string

// DeleteResult
| DeleteOk
| DeleteError of string

// ...

Answer 3

好的，正如 Romain 所解释的，多个 DU 无法解决我的问题。
我决定使用内置的 type Result< 'T,'TError>。
它使我能够避免创建许多不可避免地会发生名称冲突的 DU，从而强制在代码中使用完整的 DU 前缀。
我通过 Thomas 回复中鼓舞人心的示例解决了促使我创建自定义 DU 的问题。
（结果<,>）我有可能出现明显的错误或正常。
（注意 Result 和 Result）

type ICompanyLogic =
    abstract member Create:Company -> Result<Company, string> // CreateResult
    abstract member Update:Company -> Result<Company, string> // UpdateResult
    abstract member Delete:string -> Result<unit,string>  // DeleteResult
    
type BalanceUpdateResult = 
| Created
| Updated

type IBalanceLogic =
    abstract member CreateOrUpdate: request:BalanceUpdateRequest -> Result<BalanceUpdateResult, string>

除了 BalanceUpdateResult 之外，所有其他替换的 DU 都购买 <代码>结果<'T，'TError>。
我只是为特定任务维护了几个：

type CompanyValidation = Valid of Company | NotValid of string
type ValidateResult = Valid | NotValid of string

最后使用此解决方案：

• 我不需要定义许多 DU，
• 我可以自定义结果...在我想要的尽可能多的值内（将子 DU 存储在 Ok 或错误联合案例）
• 我不需要使用前缀或使用同义词来避免冲突（代码结果更干净）