# Constants and Variables As with any programming language, you're going to want to store information. In Swift, you have to make a distinction on if a piece of information will ever change. We do this with the keywords `let` and `var` for immutable and mutable data respectively. ```swift let x = 3 // x: Int = 3 var y = 3 // y: Int = 3 ``` Technically speaking, you could always use `var` , but it is good practice to use immutability as much as possible. Whether you are working with other people or are scared of yourself, `let` statements can be a great way of minimizing errors. Xcode will remind you to convert any variables to constants if the variable is never mutated. #### Explicit and Implied Typing Depending on what your programming background is, the above example may be slightly confusing. For Python users, the `x: Int` may be new. In Swift, a variable must always be one type. There are ways of creating a kind of loophole around this, but they're pretty advanced and rare. Moreover, data structures like arrays will also be restricted to one type–tuples can contain multiple types but must be consistent. This can seem limiting, but I promise this is a wonderful feature of compiled languages that will be very helpful. Since a variable only has one type, the compiler will be able to follow your code and will tell you if you ever violate type rules–and even sometimes help you fix them! So reiterating, the comment in the code is just to show you the type of the variable–it is not required. Something java users may have picked up on is that you don't need to tell the compiler the type that is being assigned to the variable. This is true! Swift has implicit typing, which means that if an expression obviously evaluates to a type (like an integer literal or some other function) then that variable will be inferred to be that type. For the most part, this works very well, but if you have conflicting typing (a variable being inferred to be one type at one line and another type at another line) then the compiler can get confused and will not be very helpful. In these cases, or just if you want to, you can explicitly declare the type of a variable. We do this the same way as is shown in the type annotation: ```swift let x: Int = 3 // x: Int = 3 var y: Int = 3 // y: Int = 3 ``` Now, if I were to try to assign a `Double` to a variable of type integer, the compiler will yell at me: ```swift var y: Int = 3.0 // error: cannot convert value of type 'Double' to specified type 'Int' ``` These type-annotations are the for variables and constants. #### Basic Types Some of you may be confused by the `Double` type. Doubles are floats, but with twice the precision. Quite literally, if you look at the memory required for doubles and floats they are 8 and 4 bytes respectively, which is not important. All you need to know is that doubles are the default for decimal numbers. All number types have literals–i.e. numbers with certain formats can be converted into that type. Of course, for integers, it cannot have a decimal. But Doubles and Floats have the same rules. If you want to create a Float instead of a Double, you can either initialize a float `let x = Float(0)` or do it with typing `let x: Float = 0`. Common types are: 1. Int There's a lot going on behind the scenes of integers, but unless you are doing memory-specific things (the only time I have ever cared is when doing graphics), this will not be an issue. For those that are curious, depending on the platform being used, Int will `typealias` (or convert) to either Int32 or Int64–32-bit and 64-bit integers respectively. For the most part you will be working with Int64 because Apple has switched to 64-bit systems. But, you can always directly specify if you need. 2. Doubles 3. Floats 4. Strings Sadly strings are not as easy to use as in python. You cannot index into strings, but you can copy extensions from stack overflow if you need–it's not that hard to implement. 5. Arrays and Sets See the Arrays page for more 6. And your own types being Enums, Structs, and Classes #### Wildcard There will be some instances where you will want to bind a value to an identifier but will never use it. This will come in handy when you learn about conditional binding with optionals and enums. For now, we can think of this as executing some code and throwing away the result. To do this, we assign the value to the wildcard or underscore `_`. ```swift let _ = 3 ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://ios-course.cornellappdev.com/resources/swift-foundations/constants-and-variables.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.