Como definir o tipo IntsWithoutZero em f #

Eu usaria um tipo de união de caso único para quebrar o inteiro.

Eu colocaria o tipo em seu próprio módulo e acessaria através de métodos factory e getter da seguinte forma:

    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 você quiser evitar option , alternativamente, você pode lançar uma exceção no método IntsWithoutZero.create se o usuário fornecer zero como um parâmetro.

Aqui está uma postagem no blog de Scott que faz um trabalho muito melhor explicando esse conceito:

link

Espero que isso ajude!

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

Você faz da mesma maneira: oculta o construtor de dados e expõe apenas uma função que verifica se o inteiro é maior que 0.