How does Swift's int literal to float inference work?

Swift can infer int literals to be doubles or floats

let x: Float = 3


It even works with arithmetic. It will convert everything before doing the math, so this is also 3:

let y: Float = 5/2 + 0.5


But what are the actual rules for this? There are ambiguous situations, for example if the inference is for a parameter:

func foobar(_ x: Int) -> Int
return x


func foobar(_ x: Float) -> Float
return y


foobar(1/2)


In this case it infers it as an int and returns 0, but if you delete the first function it switches to a float and returns 0.5.

What are the rules? Where is it documented?

Even more annoying is when Swift could infer it as a float but doesn't

func foobar(_ x: Float) -> Float
return x


let x = 1/2
foobar(x) // Cannot convert value of type 'Int' to expected argument type 'Float'


1

2

Int

Double

IntegerLiteralType

3 Answers
3

Literals don't have a type as such. The docs say,

If there isn’t suitable type information available, Swift infers that the
literal’s type is one of the default literal
types defined in the Swift standard library. The default types are Int
for integer literals, Double for floating-point literals, String for
string literals, and Bool for Boolean literals.

So unless your argument explicity says anything other than Int, it will infer integer literals as Int.

Int

Int

Refer this for more information, Lexical Structure - Literals.

There are two Swift behaviors at play here:

Int

With only one function, rule 1 applies. It sees that a float is needed, so it infers the division as float division and the int literals as floats:

func foobar(_ x: Float) -> Float
return y

foobar(1/2) // 0.5


If you overload the function, rule 1 no longer works. The type is now ambiguous so it falls back to the default type of Int, which luckily matches one of the definitions:

Int

func foobar(_ x: Int) -> Int
return x

func foobar(_ x: Float) -> Float
return y

foobar(1/2) // 0


See what happens if you make it so the default no longer works. Neither rule applies so you get an error:

func foobar(_ x: Double) -> Double
return x

func foobar(_ x: Float) -> Float
return y

foobar(1/2) // Ambiguous use of operator '/'


Int

IntegerLiteralType

typealias IntegerLiteralType = Double

By default, passing in 1/2 as your argument, you are performing a calculation on two Integers which will evaluate to a result of type Integer thus the first function being used.

1/2

To have a Float, one or all of the arguments have to be of type Float so either 1.0/2 or 1/2.0 or 1.0/2.0. This will cause the second function to run instead.

Float

1.0/2

1/2.0

1.0/2.0

In let x = 1/2, x is inferred to be of type Int because both 1 and 2 are of type Int.

let x = 1/2

Int

1

2

Swift will not try to infer a Float if not indicated.

Thanks for contributing an answer to Stack Overflow!

But avoid …

To learn more, see our tips on writing great answers.

Required, but never shown

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy