6

How I can define a non zero integer in F# that rise a compile time error when assigning zero value?

My question comes by watching this Scott Wlaschin video https://www.youtube.com/watch?v=E8I19uA-wGY&t=960s in minute 16:00

I have found another answers to this question in SO but all refers to a dynamic checking(throwing exception at creation time) but this approach is not a big deal and can be done in any OO and not OO languages. What I'm looking is something like: type NonZeroInteger = int except 0 or something like that.

Improve this question
8
  • 1
    Trying to figure out the scope of what you are trying to accomplish: should this type throw an exception if the result of the calculation is 0? Commented Aug 11, 2017 at 3:05
  • 1
    One approach is code contract + static verification: learn.microsoft.com/en-us/dotnet/framework/debug-trace-profile/…. I suspect F* support this although I know very little F*. Commented Aug 11, 2017 at 7:00
  • @AlexanderM my intention is not to throw exceptions but failing in compile time as the video suggested. Commented Aug 11, 2017 at 11:11
  • @FuleSnabel the contracts usually are checked in runtime and fails by throwing exceptions. What I'm aiming is for a static checked type contraint. Commented Aug 11, 2017 at 11:11
  • F# is not Idris, you could accomplish this type of validation by building it into the constructor of the type of NonZeroInteger. Commented Aug 11, 2017 at 11:42

3 Answers 3

Reset to default
8

In F# there aren't really compile time contracts for what you want to do. The F# way to deal with this would be to have a type NonZeroInteger with a private constructor and a function that returns an Option<NonZeroInteger>. This will assure that you never have Some(0).

What this does is basically forcing the developer who uses your code to account for the possibility that he might not have a NonZeroInteger after constructing one, when given the wrong integer value.

In your code you can then always safely assume that NonZeroIntegers are in fact non-zero.

open Option module A = type NonZeroInteger = private | NonZeroInteger of int static member Create (v : int) : Option<NonZeroInteger> = if v = 0 then None else Some(NonZeroInteger(v)) member this.Get : int = this |> fun (NonZeroInteger v) -> v member this.Print = this |> fun (NonZeroInteger v) -> printfn "%i" v printfn "%A" (A.NonZeroInteger(0)) // error FS1093: The union cases or fields of the type 'NonZeroInteger' are not accessible from this code location let wrong = A.NonZeroInteger.Create(0) // None let right = A.NonZeroInteger.Create(-1) // Some wrong |> Option.iter (fun x -> x.Print) // Doesn't print anything right |> Option.iter (fun x -> x.Print) // Prints -1

The private constructor prevents anyone outside your module to construct a NonZeroInteger without going through your Create function.

This makes the code quite verbose and slow, but safe. So there's definitely a tradeoff here.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

You basically answered my question in your first line. So F# doesn't has any idiomatic construct for doing what I'm looking. I reviewed all solutions until now and all can be done in any no functional programming language, so why bother using F#? I mean I feel like the video's author gave a misleading advice just to create a biased point of view about functional programming.
That's true, you could do this in C# (maybe still a bit more verbose) and basically any other statically typed language. I find this is one of the things where F# needs an easier way to do it. I wouldn't write off F# completely because it has this one functional concept that isn't easy to express in it. There are plenty of other things where F# is great IMO. Piping, partial application, Hindley-Milner type-inference, match expressions, if expressions, strong typing, tuples, partial struct copying, etc. make F# a great "functional-first" language. Is it perfect? No, but which language is?
I agree with you about that. However I'd prefer Scala because it integrates perfectly OO with functional programming, I mean within the same language I can use functional programming and OO concepts, despite having OO goodies I haven't seen in other languages like C# or Java. In the case of F# the advantage is that can be used in the .Net environment together with C#.
F# also combines functional and OO programming in one language, like I said you should look at the language as a whole instead of one missing feature. Scala is great, I'm not saying anything against it, but F# also has features (like the type inference, pipes and easy declaration of discriminated unions) that Scala doesn't have for functional. And F# is also a fully OO language.
@hdkrus I am currently learning F# and I share your sentiment. Sometimes Scott does drag C# through the mud by using older or deliberately verbose language constructs. However, many of the new features that I find he omits are actually lifted (I'm hilarious :D) from F#! You will find that it is useful that he has made these emissions as it really illustrates what the functional path should be.
2

The other answers are pretty idiomatic to F#, but here is a way to make it impossible to construct a zero value (at a slight inconvenience to the caller):

type Digit = | One = 1 | Two = 2 | Three = 3 | Four = 4 | Five = 5 | Six = 6 | Seven = 7 | Eight = 8 | Nine = 9 type NonZero private(ones, tens, hundreds, thousands, ten_thousands) = static let f (n : Digit) = int n member val num = f(ones) + 10 * tens + 100 * hundreds + 1000 * thousands + 10000 * ten_thousands new (ten_thousands, thousands, hundreds, tens, ones) = NonZero(ones, f tens, f hundreds, f thousands, f ten_thousands) new (thousands, hundreds, tens, ones) = NonZero(ones, f tens, f hundreds, f thousands, 0) new (hundreds, tens, ones) = NonZero(ones, f tens, f hundreds, 0, 0) new (tens, ones) = NonZero(ones, f tens, 0, 0, 0) new (ones) = NonZero(ones, 0, 0, 0, 0)

Here is how you would construct, say, the number 123:

let k = new NonZero(Digit.One, Digit.Two, Digit.Three)

And to retrieve the value:

let l = k.num //l is 123 : int

Hence, it is impossible to pass a zero value to a function with type NonZero -> 'a.

Improve this answer

3 Comments

> let zero : Digit = enum 0;; val zero : Digit = 0
@CurtNichols -- Good catch. If we were really serious, I suppose we could always replace the enum type with a class type, where Digit is abstract (and the cstor is private or internal) and each on of the variants is a subclass defined in the same module.
Your construct is nice but it's not what I'm asking for. This can be done in any OO language, I was looking an idiomatic resource in F# as suggested the Scott Wlaschin's video. But anyway thanks (+1) for your response.
0

You can't really do this directly, like with Scala's require for example.

Here's one way, which is somewhat DDD-ish:

type NonZeroInteger = private NonZeroInteger of int let createNZI i = if i = 0 then Error "NonZeroInteger can't be Zero" else Ok (NonZeroInteger i)

The constructor is private, so you will have to go through the createNZI function (you can switch the names if that is more natural). Than deal with the Result type. You can use Some/None instead if that is simpler. And finally unwrap the NonzeroInteger if necessary with pattern matching or an Active Pattern.

Improve this answer

2 Comments

Scala's require works in runtime, so it's basically the same than throwing exceptions. Until now I don't know any language having this feature.
@hdkrus that's because most would approach it from the validation side. Reason being that if the 0 is passed in from the outside, like from a form, you will get a run-time exception anyway. However you may want to look at Idris that has dependent types, finite sets, ranges, etc.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.