Come definire IntsWithoutZero digitare in f #

Vorrei utilizzare un singolo tipo di unione caso per racchiudere il numero intero.

Vorrei inserire il tipo nel suo modulo e accedervi tramite metodi factory e getter in questo modo:

    module IntsWithoutZero =
        // make the type constructor private
        type T = private IntsWithoutZero of int

        // factory that can apply the constraints
        let create value =
            // do check for zero here
            match value with
                | 0 -> None
                | _ -> IntsWithoutZero(value) |> Some

        // a method to extract the private data
        let value (IntsWithoutZero v) = v

    // ================== later in the code ==================
    // create the type
    let myInt = 5 |> IntsWithoutZero.create

    // ================== later when used ==================
    let myDividedValue =
        match myInt with
            | None -> None
            | Some(v) -> 
                // get value out
                let d = (v |> IntsWithoutZero.value)
                // do something zero cannot do
                Some(10 / d)

Se si desidera evitare option , in alternativa è possibile generare un'eccezione nel metodo IntsWithoutZero.create se l'utente ha fornito zero come parametro.

Ecco un post sul blog di Scott che fa un lavoro molto migliore spiegando questo concetto:

link

Spero che questo aiuti!

I know how I'd do it with OO approach (e.g. write a IntWihtoutZero class and disallow 0 during construction).

Lo fai allo stesso modo: nascondi il costruttore di dati e esponi solo una funzione che controlla se il numero intero è maggiore di 0.