有没有办法将 class 与 F# 中的有区别的联合混合？

Question

I think it would be convenient to have a discriminated union type with an initializer. My idea is to combine something like this:

type Result =
| Ok of string
| Error of int

With something like that:

type Result(someData) =
    if SomeData = true then
        this class is Ok "all good"
    else
        this class is Error 100

Is there some clever syntactic way to make an object that can take an input, run some logic and end up with several states that can be used directly in a match statement?

(or, if this idea is not good, I'd be happy to hear why too)

Answer 1

Scott Wlaschin suggests an interesting approach that I think deals with your requests. The basic idea is to define DU constructors as private inside a Module, so that the only way to create a type is by a custom "creation" function inside that module. I inserted Active Patterns in the example bellow to address your "can be used directly in a match statement" request:

module User =
    type UserID =
        private //this is important! prevents accessing the constructors outside this module
        | String10Constructor of string
        | String20Constructor of string

    let createUser s =
        if String.length s <= 10 then s |> String10Constructor |> Ok
        elif String.length s <= 20 then s |> String20Constructor |> Ok
        else Error "String lenght should be less than 21."

    let (|User10|User20|) = function
        | String10Constructor s -> User10 s
        | String20Constructor s -> User20 s

open User

let tryToCreateUser s = 
    match createUser s with
    | Ok u ->
        match u with
        | User10 s -> sprintf "User10: %s" s
        | User20 s -> sprintf "User20: %s" s
    | Error e -> e

tryToCreateUser "1111111254545454543345678911" //ouput: "String lenght should be less than 10."

tryToCreateUser "10" //ouput: "User10: 10"

tryToCreateUser "1044646546546466" //ouput: "User20: 1044646546546466"

//you cannot override createUser by trying to access the constructor directly
//(error: "not accessible from this code location)
    let x = String10Constructor ""

Answer 2

The idea isn't feasible for discriminated unions because they are immutable structures, and only class types may take in constructors.

That said, there are alternatives.

Shadowing

type Result =
| Ok of string
| Error of int

let Result someData =
    if someData then
        Ok "all good"
    else
        Error 100

gets you the kind of semantics you'd expect.

Factory method

type Result =
| Ok of string
| Error of int with
    static member Create(someData) =
        if someData then
            Ok "all good"
        else
            Error 100

and then Result.Create false . You can have multiple overloaded factory methods.