Custom ExpressibleByFloatLiteral types?

Using Swift
1

I recently had to make heavy use of Foundation.Decimal, which is cumbersome, because instead of writing let d: Decimal = 25.4, I have to write let d = Decimal(string: “25.4”), or the compiler will push 25.4 through Double, and the result is more like 25.3999996185302734375.

Is there any way to write an initializer that gets handed the literal string in the code for a numeric value, rather than relying on the compiler to first turn it into a float?

2 Likes
2

No. You can make Decimal conform to ExpressibleByStringLiteral, but there's no way to get a numeric literal as a String. Maybe we could add another FloatLiteralType that would be able to maintain full precision, but I don't think we could update Decimal's conformance to use it. I usually wrap Decimal into type named the way I want, like Money, and make sure that type only conforms to protocols that can accurately model the Decimal.

3

Unfortunately, there’s no way to wrap Decimal to allow writing a literal floating point number that preserves precision. You have to pass it a string.

I think it would be really cool if there was a way be passed the floating literal string by the compiler. I could add conformance for Decimal in an extension, and various higher-precision libraries (like the one planned for swift-numerics) could take advantage of it, too.

4

There was a brief discussion adjacent to SE-0368:

Along similar lines, it is intentional that StaticBigInt cannot represent fractional values. Integer types should not be constructible with fractional literals, and allowing that simply adds unnecessary costs and introduces a new way for construction to fail. It is still a language goal for Swift to someday support dynamically flexible floating-point literals the way it does for integer literals, but that is a separable project from introducing StaticBigInt.

5

You're right. Wrapping it just allows you to drop the broken ExpressibleByFloatLiteral conformance and add API appropriate for your intended usage that maintains precision, usually by using String, unfortunately.

6

You could maybe traffic the syntax through a macro to retain the precision:

#Decimal(25.4)
// expands to:
// Decimal(string: "25.4")
3 Likes
7

No, this longstanding limitation of float literals is tracked by SR-920, SR-3317, SR-7124, and other ancient bug reports.

The solution is more or less entirely outlined but there have not been engineering resources devoted to make it happen.

2 Likes
8

FWIW, your example as written works quite alright:

let d1: Decimal = 25.4
let d2 = Decimal(string: "25.4")!
print(d1, d2) // 25.4 25.4
print(d1 == d2) // true
9

It will work whenever the literal can be exactly represented by a Double, which isn't good enough for most usage of Decimal.

1 Like