How to typespec a float range in Elixir?

You can’t have float range in typespecs. There is no such expressions by design.

Don’t forget to mark the correct answer

So what I am asking here is impossible?
Are there any alternatives to this?

Yes, it is impossible in current typespecs language. Dialyzer will reduce complexity of every integer range typespec into integer() during checking (that’s how dialyzer works). So you can just write float() with a comment next to it (like float() # from 1.0 to 2.0) without any significant impact on type checking.

I decided to use float and guards in the function. It is not the ideal situation, but its better than having no checks at all.

For those of you reading only the solution, @hissssst provided detailed reasons as to why the solution I wanted to achieve is not possible (see How to typespec a float range in Elixir? - #4 by hst337)

For a more detailed explanation, there is this SO answer:

Basically, this all comes down to the type I am trying to create - a dependant type (a type that depends both on the value and type of the parameter). Because here the range of possible values is infinity, this is not possible.

Some type systems have infinite ranges of values. The problem is that Dialyzer’s type system doesn’t. And no, this type is not dependant. The author of SO answer is completely wrong

This has nothing to do with dependent types and it would be trivial for dialyzer and other tools to support this. If we were so inclined we could even support things like :foo .. :bar to cover the range of all atoms from :foo to :bar, or why not {any(), 53, float()} .. {12, atom(), map()} and other arbitrary ranges? There’s nothing stopping us from doing so.

The problem is that Dialyzer’s type system doesn’t.

dialyzer does not have a “type system,” it’s untyped and only reasons about sets of possible values (which may be infinite). That you cannot express arbitrary sets of possible values through @type annotations (@value_constraint would have been a better name) is nothing more than a limitation in the current implementation of the “type language.”

Yes, I meant expressiveness of type language. But dialyzer has a type system, Type system - Wikipedia, it is just pluggable and gradual without any impact on runtime or performance

Can you elaborate on why a function that returns @type percentage :: 0.0..1.0 is not a function returning a dependent type?

From the wikia:

(…) In computer science and logic, a dependent type is a type whose definition depends on a value [in addition to its type] (…)

This makes sense to me. The percentage() type, were it to exist, would depend not only on parameter being a float but also on the value of said float to be between 0.0 .. 1.0.

Can you elaborate as to why percentage() cannot be considered a dependent type?

How so? How could I make this work?

No, dependent type is a type which depends on the value
For example, if Erlang/Elixir was a statically typed language, maps there would be dependent. When their size is less than 33 items, they use flatmap implementation, while for bigger sizes they use hashmap implementation. So, in this example the type depends on the size of the map

While for float ranges, it is just a range, and it is not a dependant type. It is just a subtype of the float, and that’s all. Like uint is a subtype of int (without maximum integer limit of course), which bounds the integer to always be not less than 0