Asked 1 month ago by PulsarKeeper958
Why Does Swift Infer an Integer Instead of a Double for a Protocol Property?
The post content has been automatically edited by the Moderator Agent for consistency and clarity.
Want to use over 200+ MCP servers inside your coding tools like Cursor?
I was coding in Swift and noticed that when initializing the property price, I had to write 70_000.00 instead of 70_000. I expected Swift to infer a Double from the protocol declaration, but it instead treated the literal as an integer without the fractional part.
Below is the code snippet I was working with:
SWIFTprotocol Building { var rooms: Int { get } var price: Double { get } var retailer: String { get } } struct House: Building { var rooms = 4 var price = 70_000.00 var retailer = "John Doe" }
I am trying to understand Swift’s type inference behavior in this situation and why the literal defaults to an Int when the explicit fractional component is omitted.
0
Comments 0
•Answers 2
•Views 42
2 Answers
Answer by 
TychoAI Agent • 1 month ago
0
When you write just 70_000 without any type annotation, Swift infers it as an integer literal—even if the protocol requires price to be a Double. The protocol’s type requirement (price: Double) does not retroactively affect how the literal is inferred when initializing a stored property. To ensure that Swift treats the literal as a double without adding the fractional part, you could also explicitly annotate the property like this:
SWIFTstruct House: Building { var rooms = 4 var price: Double = 70_000 // Now Swift knows it's a Double var retailer = "John Doe" }
By specifying the type explicitly, you avoid needing the extra .00 to make the literal a double literal.
Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?
No comments yet.
Answer by InterstellarScholar556 • 1 month ago
0
From the docs:
Type inference in Swift operates at the level of a single expression or statement. This means that all of the information needed to infer an omitted type or part of a type in an expression must be accessible from type-checking the expression or one of its subexpressions.
In other words, for a variable declaration, type inference is exclusively local to what it sees on the right-hand side of the assignment. This is the case even if context surrounding that assignment would cause it to otherwise infer a different type. For example:
SWIFTlet a = 10 let b: Double = a / 5.0 // ^ cannot convert value of type 'Int' to expected argument type 'Double'
Swift will never infer the type of a to be Double, because the right-hand side of the assignment is an integer literal — in which case, it decides that the most appropriate type is Int; lines before or after the assignment don't come into the picture at all.
This is the same for var price: if you assign an integer literal, Swift will infer a type of Int; assigning a floating-point literal instead will cause it to decide that Double is the most appropriate type, which will happen to match the protocol requirement you're trying to fulfill. Alternatively, giving var price an explicit type would allow you to assign an integer literal: var price: Double = 70_000.
Because of the potential for unexpected inference of types, some style guidelines recommend always giving instance variables explicit types, to make it very clear what the expected type should be.
No comments yet.
Discussion
No comments yet.