The Swift Programming Language 1st Apple Inc

download

https://ebookbell.com/product/the-swift-programming-language-1st-
apple-inc-4690502

Explore and download more ebooks at ebookbell.com

Here are some recommended products that we believe you will be
interested in. You can click the link to download.

The Swift Programming Language Swift 57 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-57-apple-inc-50090374

The Swift Programming Language Swift 21 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-21-apple-inc-57954152

The Swift Programming Language Inc Apple

https://ebookbell.com/product/the-swift-programming-language-inc-
apple-22130798

The Swift Programming Language Apple Inc

https://ebookbell.com/product/the-swift-programming-language-apple-
inc-34614754
The Swift Programming Language Swift 53 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-53-apple-inc-34614756

The Swift Programming Language Swift 55 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-55-apple-inc-36444848

The Swift Programming Language Swift 57 57 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-57-57-apple-inc-44480436

The Swift Programming Language Prerelease Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
prerelease-apple-inc-4690428

The Swift Programming Language Swift 4 Apple Inc

https://ebookbell.com/product/the-swift-programming-language-
swift-4-apple-inc-7177452
Welcome to Swift
About Swift

Swift is a new programming language for iOS and OS X apps that builds on the best of C
and Objective-C, without the constraints of C compatibility. Swift adopts safe
programming patterns and adds modern features to make programming easier, more
flexible, and more fun. Swift’s clean slate, backed by the mature and much-loved Cocoa
and Cocoa Touch frameworks, is an opportunity to reimagine how software development
works.
Swift has been years in the making. Apple laid the foundation for Swift by advancing our
existing compiler, debugger, and framework infrastructure. We simplified memory
management with Automatic Reference Counting (ARC). Our framework stack, built on
the solid base of Foundation and Cocoa, has been modernized and standardized
throughout. Objective-C itself has evolved to support blocks, collection literals, and
modules, enabling framework adoption of modern language technologies without
disruption. Thanks to this groundwork, we can now introduce a new language for the
future of Apple software development.
Swift feels familiar to Objective-C developers. It adopts the readability of Objective-C’s
named parameters and the power of Objective-C’s dynamic object model. It provides
seamless access to existing Cocoa frameworks and mix-and-match interoperability with
Objective-C code. Building from this common ground, Swift introduces many new features
and unifies the procedural and object-oriented portions of the language.
Swift is friendly to new programmers. It is the first industrial-quality systems
programming language that is as expressive and enjoyable as a scripting language. It
supports playgrounds, an innovative feature that allows programmers to experiment with
Swift code and see the results immediately, without the overhead of building and running
an app.
Swift combines the best in modern language thinking with wisdom from the wider Apple
engineering culture. The compiler is optimized for performance, and the language is
optimized for development, without compromising on either. It’s designed to scale from
“hello, world” to an entire operating system. All this makes Swift a sound future
investment for developers and for Apple.
Swift is a fantastic way to write iOS and OS X apps, and will continue to evolve with new
features and capabilities. Our goals for Swift are ambitious. We can’t wait to see what
you create with it.
A Swift Tour

Tradition suggests that the first program in a new language should print the words “Hello,
world” on the screen. In Swift, this can be done in a single line:

println("Hello, world")

If you have written code in C or Objective-C, this syntax looks familiar to you—in Swift,
this line of code is a complete program. You don’t need to import a separate library for
functionality like input/output or string handling. Code written at global scope is used as
the entry point for the program, so you don’t need a main function. You also don’t need to
write semicolons at the end of every statement.
This tour gives you enough information to start writing code in Swift by showing you how
to accomplish a variety of programming tasks. Don’t worry if you don’t understand
something—everything introduced in this tour is explained in detail in the rest of this
book.

NOT E
For the best experience, open this chapter as a playground in Xcode. Playgrounds allow you to edit the code
listings and see the result immediately.

Simple Values
Use let to make a constant and var to make a variable. The value of a constant doesn’t
need to be known at compile time, but you must assign it a value exactly once. This
means you can use constants to name a value that you determine once but use in many
places.

var myVariable = 42

myVariable = 50

let myConstant = 42

A constant or variable must have the same type as the value you want to assign to it.
However, you don’t always have to write the type explicitly. Providing a value when you
create a constant or variable lets the compiler infer its type. In the example above, the
compiler infers that myVariable is an integer because its initial value is a integer.
If the initial value doesn’t provide enough information (or if there is no initial value),
specify the type by writing it after the variable, separated by a colon.

let implicitInteger = 70

let implicitDouble = 70.0

let explicitDouble: Double = 70

EX PERI M ENT
Create a constant with an explicit type of Float and a value of 4.

Values are never implicitly converted to another type. If you need to convert a value to a
different type, explicitly make an instance of the desired type.

let label = "The width is "

let width = 94

let widthLabel = label + String(width)

EX PERI M ENT
Try removing the conversion to String from the last line. What error do you get?

There’s an even simpler way to include values in strings: Write the value in parentheses,
and write a backslash (\) before the parentheses. For example:

let apples = 3

let oranges = 5

let appleSummary = "I have \(apples) apples."

let fruitSummary = "I have \(apples + oranges) pieces of fruit."

EX PERI M ENT
Use \() to include a floating-point calculation in a string and to include someone’s name in a greeting.
Create arrays and dictionaries using brackets ([]), and access their elements by writing
the index or key in brackets.

var shoppingList = ["catfish", "water", "tulips", "blue paint"]

shoppingList[1] = "bottle of water"

var occupations = [

"Malcolm": "Captain",

"Kaylee": "Mechanic",

occupations["Jayne"] = "Public Relations"

To create an empty array or dictionary, use the initializer syntax.

let emptyArray = String[]()

let emptyDictionary = Dictionary<String, Float>()

If type information can be inferred, you can write an empty array as [] and an empty
dictionary as [:]—for example, when you set a new value for a variable or pass an
argument to a function.

shoppingList = [] // Went shopping and bought everything.

Control Flow
Use if and switch to make conditionals, and use for-in, for, while, and do-while to make loops.
Parentheses around the condition or loop variable are optional. Braces around the body
are required.

let individualScores = [75, 43, 103, 87, 12]

var teamScore = 0

for score in individualScores {

if score > 50 {

teamScore += 3

} else {
 teamScore += 1

mScore

In an if statement, the conditional must be a Boolean expression—this means that code

such as if score { ... } is an error, not an implicit comparison to zero.
You can use if and let together to work with values that might be missing. These values
are represented as optionals. An optional value either contains a value or contains nil to
indicate that the value is missing. Write a question mark (?) after the type of a value to
mark the value as optional.

var optionalString: String? = "Hello"

optionalString == nil

var optionalName: String? = "John Appleseed"

var greeting = "Hello!"

if let name = optionalName {

greeting = "Hello, \(name)"

EX PERI M ENT
Change optionalName to nil. What greeting do you get? Add an else clause that sets a different greeting if
optionalName is nil.

If the optional value is nil, the conditional is false and the code in braces is skipped.
Otherwise, the optional value is unwrapped and assigned to the constant after let, which
makes the unwrapped value available inside the block of code.
Switches support any kind of data and a wide variety of comparison operations—they
aren’t limited to integers and tests for equality.

let vegetable = "red pepper"

switch vegetable {

case "celery":
 let vegetableComment = "Add some raisins and make ants on a log."

case "cucumber", "watercress":

let vegetableComment = "That would make a good tea sandwich."

case let x where x.hasSuffix("pepper"):

let vegetableComment = "Is it a spicy \(x)?"

default:

vegetableComment = "Everything tastes good in soup."

EX PERI M ENT
Try removing the default case. What error do you get?

After executing the code inside the switch case that matched, the program exits from the
switch statement. Execution doesn’t continue to the next case, so there is no need to
explicitly break out of the switch at the end of each case’s code.
You use for-in to iterate over items in a dictionary by providing a pair of names to use for
each key-value pair.

let interestingNumbers = [

"Prime": [2, 3, 5, 7, 11, 13],

"Fibonacci": [1, 1, 2, 3, 5, 8],

"Square": [1, 4, 9, 16, 25],

var largest = 0

for (kind, numbers) in interestingNumbers {

for number in numbers {

if number > largest {

largest = number

}
st

EX PERI M ENT
Add another variable to keep track of which kind of number was the largest, as well as what that largest
number was.

Use while to repeat a block of code until a condition changes. The condition of a loop can
be at the end instead, ensuring that the loop is run at least once.

var n = 2

while n < 100 {

n=n*2

var m = 2

do {

m=m*2

ile m < 100

You can keep an index in a loop—either by using .. to make a range of indexes or by

writing an explicit initialization, condition, and increment. These two loops do the same
thing:

var firstForLoop = 0

for i in 0..3 {

firstForLoop += i

firstForLoop

var secondForLoop = 0

for var i = 0; i < 3; ++i {

 secondForLoop += 1

ndForLoop

Use .. to make a range that omits its upper value, and use ... to make a range that
includes both values.

Functions and Closures

Use func to declare a function. Call a function by following its name with a list of
arguments in parentheses. Use -> to separate the parameter names and types from the
function’s return type.

func greet(name: String, day: String) -> String {

return "Hello \(name), today is \(day)."

greet("Bob", "Tuesday")

EX PERI M ENT
Remove the day parameter. Add a parameter to include today’s lunch special in the greeting.

Use a tuple to return multiple values from a function.

func getGasPrices() -> (Double, Double, Double) {

return (3.59, 3.69, 3.79)

getGasPrices()

Functions can also take a variable number of arguments, collecting them into an array.

func sumOf(numbers: Int...) -> Int {

var sum = 0

for number in numbers {

sum += number
 }

return sum

sumOf()

sumOf(42, 597, 12)

EX PERI M ENT
Write a function that calculates the average of its arguments.

Functions can be nested. Nested functions have access to variables that were declared in
the outer function. You can use nested functions to organize the code in a function that is
long or complex.

func returnFifteen() -> Int {

var y = 10

func add() {

y += 5

add()

return y

returnFifteen()

Functions are a first-class type. This means that a function can return another function as
its value.

func makeIncrementer() -> (Int -> Int) {

func addOne(number: Int) -> Int {

return 1 + number

return addOne

var increment = makeIncrementer()

 increment(7)

A function can take another function as one of its arguments.

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {

for item in list {

if condition(item) {

return true

return false

func lessThanTen(number: Int) -> Bool {

eturn number < 10

numbers = [20, 19, 7, 12]

AnyMatches(numbers, lessThanTen)

Functions are actually a special case of closures. You can write a closure without a name
by surrounding code with braces ({}). Use in to separate the arguments and return type
from the body.

numbers.map({

(number: Int) -> Int in

let result = 3 * number

return result

})

EX PERI M ENT
Rewrite the closure to return zero for all odd numbers.

You have several options for writing closures more concisely. When a closure’s type is
already known, such as the callback for a delegate, you can omit the type of its
parameters, its return type, or both. Single statement closures implicitly return the value
of their only statement.

numbers.map({ number in 3 * number })

You can refer to parameters by number instead of by name—this approach is especially

useful in very short closures. A closure passed as the last argument to a function can
appear immediately after the parentheses.

sort([1, 5, 3, 12, 2]) { $0 > $1 }

Objects and Classes

Use class followed by the class’s name to create a class. A property declaration in a class is
written the same way as a constant or variable declaration, except that it is in the
context of a class. Likewise, method and function declarations are written the same way.

class Shape {

var numberOfSides = 0

func simpleDescription() -> String {

return "A shape with \(numberOfSides) sides."

EX PERI M ENT
Add a constant property with let, and add another method that takes an argument.

Create an instance of a class by putting parentheses after the class name. Use dot syntax
to access the properties and methods of the instance.

var shape = Shape()

shape.numberOfSides = 7

var shapeDescription = shape.simpleDescription()

This version of the Shape class is missing something important: an initializer to set up the
class when an instance is created. Use init to create one.

class NamedShape {

var numberOfSides: Int = 0

var name: String

init(name: String) {

self.name = name

func simpleDescription() -> String {

return "A shape with \(numberOfSides) sides."

Notice how self is used to distinguish the name property from the name argument to the
initializer. The arguments to the initializer are passed like a function call when you create
an instance of the class. Every property needs a value assigned—either in its declaration
(as with numberOfSides) or in the initializer (as with name).
Use deinit to create a deinitializer if you need to perform some cleanup before the object is
deallocated.
Subclasses include their superclass name after their class name, separated by a colon.
There is no requirement for classes to subclass any standard root class, so you can
include or omit a superclass as needed.
Methods on a subclass that override the superclass’s implementation are marked with
override—overriding a method by accident, without override, is detected by the compiler as an
error. The compiler also detects methods with override that don’t actually override any
method in the superclass.

class Square: NamedShape {

var sideLength: Double

init(sideLength: Double, name: String) {

self.sideLength = sideLength
 super.init(name: name)

numberOfSides = 4

unc area() -> Double {

return sideLength * sideLength

verride func simpleDescription() -> String {

return "A square with sides of length \(sideLength)."

est = Square(sideLength: 5.2, name: "my test square")

area()

simpleDescription()

EX PERI M ENT
Make another subclass of NamedShape called Circle that takes a radius and a name as arguments to its
initializer. Implement an area and a describe method on the Circle class.

In addition to simple properties that are stored, properties can have a getter and a
setter.

class EquilateralTriangle: NamedShape {

var sideLength: Double = 0.0

init(sideLength: Double, name: String) {

self.sideLength = sideLength

super.init(name: name)

numberOfSides = 3

}
ar perimeter: Double {

et {

return 3.0 * sideLength

et {

sideLength = newValue / 3.0

verride func simpleDescription() -> String {

return "An equilateral triagle with sides of length \(sideLength)."

riangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")

gle.perimeter

gle.perimeter = 9.9

gle.sideLength

In the setter for perimeter, the new value has the implicit name newValue. You can provide an
explicit name in parentheses after set.
Notice that the initializer for the EquilateralTriangle class has three different steps:

1. Setting the value of properties that the subclass declares.

2. Calling the superclass’s initializer.
3. Changing the value of properties defined by the superclass. Any additional setup
work that uses methods, getters, or setters can also be done at this point.

If you don’t need to compute the property but still need to provide code that is run before
and after setting a new value, use willSet and didSet. For example, the class below ensures
that the side length of its triangle is always the same as the side length of its square.

class TriangleAndSquare {

var triangle: EquilateralTriangle {

 willSet {

square.sideLength = newValue.sideLength

var square: Square {

willSet {

triangle.sideLength = newValue.sideLength

(size: Double, name: String) {

square = Square(sideLength: size, name: name)

triangle = EquilateralTriangle(sideLength: size, name: name)

riangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")

gleAndSquare.square.sideLength

gleAndSquare.triangle.sideLength

gleAndSquare.square = Square(sideLength: 50, name: "larger square")

gleAndSquare.triangle.sideLength

Methods on classes have one important difference from functions. Parameter names in
functions are used only within the function, but parameters names in methods are also
used when you call the method (except for the first parameter). By default, a method has
the same name for its parameters when you call it and within the method itself. You can
specify a second name, which is used inside the method.

class Counter {

var count: Int = 0

func incrementBy(amount: Int, numberOfTimes times: Int) {

count += amount * times

var counter = Counter()

 counter.incrementBy(2, numberOfTimes: 7)

When working with optional values, you can write ? before operations like methods,
properties, and subscripting. If the value before the ? is nil, everything after the ? is
ignored and the value of the whole expression is nil. Otherwise, the optional value is
unwrapped, and everything after the ? acts on the unwrapped value. In both cases, the
value of the whole expression is an optional value.

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")

let sideLength = optionalSquare?.sideLength

Enumerations and Structures

Use enum to create an enumeration. Like classes and all other named types, enumerations
can have methods associated with them.

enum Rank: Int {

case Ace = 1

case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten

case Jack, Queen, King

func simpleDescription() -> String {

switch self {

case .Ace:

return "ace"

case .Jack:

return "jack"

case .Queen:

return "queen"

case .King:

return "king"

default:

return String(self.toRaw())

}
ce = Rank.Ace

ceRawValue = ace.toRaw()

EX PERI M ENT
Write a function that compares two Rank values by comparing their raw values.

In the example above, the raw value type of the enumeration is Int, so you only have to
specify the first raw value. The rest of the raw values are assigned in order. You can also
use strings or floating-point numbers as the raw type of an enumeration.
Use the toRaw and fromRaw functions to convert between the raw value and the enumeration
value.

if let convertedRank = Rank.fromRaw(3) {

let threeDescription = convertedRank.simpleDescription()

The member values of an enumeration are actual values, not just another way of writing
their raw values. In fact, in cases where there isn’t a meaningful raw value, you don’t
have to provide one.

enum Suit {

case Spades, Hearts, Diamonds, Clubs

func simpleDescription() -> String {

switch self {

case .Spades:

return "spades"

case .Hearts:

return "hearts"

case .Diamonds:

return "diamonds"

case .Clubs:
 return "clubs"

earts = Suit.Hearts

eartsDescription = hearts.simpleDescription()

EX PERI M ENT
Add a color method to Suit that returns “black” for spades and clubs, and returns “red” for hearts and
diamonds.

Notice the two ways that the Hearts member of the enumeration is referred to above:
When assigning a value to the hearts constant, the enumeration member Suit.Hearts is
referred to by its full name because the constant doesn’t have an explicit type specified.
Inside the switch, the enumeration is referred to by the abbreviated form .Hearts because
the value of self is already known to be a suit. You can use the abbreviated form anytime
the value’s type is already known.
Use struct to create a structure. Structures support many of the same behaviors as classes,
including methods and initializers. One of the most important differences between
structures and classes is that structures are always copied when they are passed around
in your code, but classes are passed by reference.

struct Card {

var rank: Rank

var suit: Suit

func simpleDescription() -> String {

return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"

let threeOfSpades = Card(rank: .Three, suit: .Spades)

let threeOfSpadesDescription = threeOfSpades.simpleDescription()

EX PERI M ENT
 Add a method to Card that creates a full deck of cards, with one card of each combination of rank and suit.

An instance of an enumeration member can have values associated with the instance.
Instances of the same enumeration member can have different values associated with
them. You provide the associated values when you create the instance. Associated values
and raw values are different: The raw value of an enumeration member is the same for
all of its instances, and you provide the raw value when you define the enumeration.
For example, consider the case of requesting the sunrise and sunset time from a server.
The server either responds with the information or it responds with some error
information.

enum ServerResponse {

case Result(String, String)

case Error(String)

let success = ServerResponse.Result("6:00 am", "8:09 pm")

let failure = ServerResponse.Error("Out of cheese.")

switch success {

let .Result(sunrise, sunset):

serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."

let .Error(error):

serverResponse = "Failure... \(error)"

EX PERI M ENT
Add a third case to ServerResponse and to the switch.

Notice how the sunrise and sunset times are extracted from the ServerResponse value as part
of matching the value against the switch cases.
 Protocols and Extensions
Use protocol to declare a protocol.

protocol ExampleProtocol {

var simpleDescription: String { get }

mutating func adjust()

Classes, enumerations, and structs can all adopt protocols.

class SimpleClass: ExampleProtocol {

var simpleDescription: String = "A very simple class."

var anotherProperty: Int = 69105

func adjust() {

simpleDescription += " Now 100% adjusted."

var a = SimpleClass()

a.adjust()

Description = a.simpleDescription

SimpleStructure: ExampleProtocol {

ar simpleDescription: String = "A simple structure"

mutating func adjust() {

simpleDescription += " (adjusted)"

= SimpleStructure()

just()

Description = b.simpleDescription

EX PERI M ENT
 EX PERI M ENT
Write an enumeration that conforms to this protocol.

Notice the use of the mutating keyword in the declaration of SimpleStructure to mark a method
that modifies the structure. The declaration of SimpleClass doesn’t need any of its methods
marked as mutating because methods on a class can always modify the class.
Use extension to add functionality to an existing type, such as new methods and computed
properties. You can use an extension to add protocol conformance to a type that is
declared elsewhere, or even to a type that you imported from a library or framework.

extension Int: ExampleProtocol {

var simpleDescription: String {

return "The number \(self)"

mutating func adjust() {

self += 42

7.simpleDescription

EX PERI M ENT
Write an extension for the Double type that adds an absoluteValue property.

You can use a protocol name just like any other named type—for example, to create a
collection of objects that have different types but that all conform to a single protocol.
When you work with values whose type is a protocol type, methods outside the protocol
definition are not available.

let protocolValue: ExampleProtocol = a

protocolValue.simpleDescription

// protocolValue.anotherProperty // Uncomment to see the error

Even though the variable protocolValue has a runtime type of SimpleClass, the compiler treats it
as the given type of ExampleProtocol. This means that you can’t accidentally access methods
or properties that the class implements in addition to its protocol conformance.
Generics

Write a name inside angle brackets to make a generic function or type.

func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {

var result = ItemType[]()

for i in 0..times {

result += item

return result

repeat("knock", 4)

You can make generic forms of functions and methods, as well as classes, enumerations,
and structures.

// Reimplement the Swift standard library's optional type

enum OptionalValue<T> {

case None

case Some(T)

var possibleInteger: OptionalValue<Int> = .None

possibleInteger = .Some(100)

Use where after the type name to specify a list of requirements—for example, to require
the type to implement a protocol, to require two types to be the same, or to require a
class to have a particular superclass.

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable,

T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {

for lhsItem in lhs {

for rhsItem in rhs {

if lhsItem == rhsItem {
 return true

return false

CommonElements([1, 2, 3], [3])

EX PERI M ENT
Modify the anyCommonElements function to make a function that returns an array of the elements that any
two sequences have in common.

In the simple cases, you can omit where and simply write the protocol or class name after
a colon. Writing <T: Equatable> is the same as writing <T where T: Equatable>.
Language Guide
The Basics

Swift is a new programming language for iOS and OS X app development. Nonetheless,
many parts of Swift will be familiar from your experience of developing in C and
Objective-C.
Swift provides its own versions of all fundamental C and Objective-C types, including Int
for integers; Double and Float for floating-point values; Bool for Boolean values; and String for
textual data. Swift also provides powerful versions of the two primary collection types,
Array and Dictionary , as described in Collection Types.

Like C, Swift uses variables to store and refer to values by an identifying name. Swift also
makes extensive use of variables whose values cannot be changed. These are known as
constants, and are much more powerful than constants in C. Constants are used
throughout Swift to make code safer and clearer in intent when you work with values that
do not need to change.
In addition to familiar types, Swift introduces advanced types not found in Objective-C.
These include tuples, which enable you to create and pass around groupings of values.
Tuples can return multiple values from a function as a single compound value.
Swift also introduces optional types, which handle the absence of a value. Optionals say
either “there is a value, and it equals x” or “there isn’t a value at all”. Optionals are
similar to using nil with pointers in Objective-C, but they work for any type, not just
classes. Optionals are safer and more expressive than nil pointers in Objective-C and are
at the heart of many of Swift’s most powerful features.
Optionals are an example of the fact that Swift is a type safe language. Swift helps you to
be clear about the types of values your code can work with. If part of your code expects a
String, type safety prevents you from passing it an Int by mistake. This enables you to catch
and fix errors as early as possible in the development process.

Constants and Variables

Constants and variables associate a name (such as maximumNumberOfLoginAttempts or
welcomeMessage) with a value of a particular type (such as the number 10 or the string "Hello").
The value of a constant cannot be changed once it is set, whereas a variable can be set
to a different value in the future.
Declaring Constants and Variables
Constants and variables must be declared before they are used. You declare constants
with the let keyword and variables with the var keyword. Here’s an example of how
constants and variables can be used to track the number of login attempts a user has
made:

let maximumNumberOfLoginAttempts = 10

var currentLoginAttempt = 0

This code can be read as:

“Declare a new constant called maximumNumberOfLoginAttempts, and give it a value of 10. Then,
declare a new variable called currentLoginAttempt, and give it an initial value of 0.”
In this example, the maximum number of allowed login attempts is declared as a
constant, because the maximum value never changes. The current login attempt counter
is declared as a variable, because this value must be incremented after each failed login
attempt.
You can declare multiple constants or multiple variables on a single line, separated by
commas:

var x = 0.0, y = 0.0, z = 0.0

NOT E
If a stored value in your code is not going to change, always declare it as a constant with the let keyword.
Use variables only for storing values that need to be able to change.

Type Annotations
You can provide a type annotation when you declare a constant or variable, to be clear
about the kind of values the constant or variable can store. Write a type annotation by
placing a colon after the constant or variable name, followed by a space, followed by the
name of the type to use.
This example provides a type annotation for a variable called welcomeMessage, to indicate
that the variable can store String values:

var welcomeMessage: String

The colon in the declaration means “…of type…,” so the code above can be read as:
“Declare a variable called welcomeMessage that is of type String.”

The phrase “of type String” means “can store any String value.” Think of it as meaning “the
type of thing” (or “the kind of thing”) that can be stored.
The welcomeMessage variable can now be set to any string value without error:

welcomeMessage = "Hello"

NOT E
It is rare that you need to write type annotations in practice. If you provide an initial value for a constant or
variable at the point that it is defined, Swift can almost always infer the type to be used for that constant or
variable, as described in Type Safety and Type Inference. In the welcomeMessage example above, no initial
value is provided, and so the type of the welcomeMessage variable is specified with a type annotation rather
than being inferred from an initial value.

Naming Constants and Variables

You can use almost any character you like for constant and variable names, including
Unicode characters:

let π = 3.14159

let 你好 = "你好世界"

let = "dogcow"

Constant and variable names cannot contain mathematical symbols, arrows, private-use
(or invalid) Unicode code points, or line- and box-drawing characters. Nor can they begin
with a number, although numbers may be included elsewhere within the name.
Once you’ve declared a constant or variable of a certain type, you can’t redeclare it again
with the same name, or change it to store values of a different type. Nor can you change
a constant into a variable or a variable into a constant.

NOT E
If you need to give a constant or variable the same name as a reserved Swift keyword, you can do so by
surrounding the keyword with back ticks (`) when using it as a name. However, you should avoid using
 keywords as names unless you have absolutely no choice.

You can change the value of an existing variable to another value of a compatible type.
In this example, the value of friendlyWelcome is changed from "Hello!" to "Bonjour!":

var friendlyWelcome = "Hello!"

friendlyWelcome = "Bonjour!"

// friendlyWelcome is now "Bonjour!"

Unlike a variable, the value of a constant cannot be changed once it is set. Attempting to
do so is reported as an error when your code is compiled:

let languageName = "Swift"

languageName = "Swift++"

// this is a compile-time error - languageName cannot be changed

Printing Constants and Variables

You can print the current value of a constant or variable with the println function:

println(friendlyWelcome)

// prints "Bonjour!"

is a global function that prints a value, followed by a line break, to an appropriate

println
output. If you are working in Xcode, for example, println prints its output in Xcode’s
“console” pane. (A second function, print, performs the same task without appending a line
break to the end of the value to be printed.)
The println function prints any String value you pass to it:

println("This is a string")

// prints "This is a string"

The println function can print more complex logging messages, in a similar manner to
Cocoa’s NSLog function. These messages can include the current values of constants and
variables.
Swift uses string interpolation to include the name of a constant or variable as a
placeholder in a longer string, and to prompt Swift to replace it with the current value of
that constant or variable. Wrap the name in parentheses and escape it with a backslash
before the opening parenthesis:

println("The current value of friendlyWelcome is \(friendlyWelcome)")

// prints "The current value of friendlyWelcome is Bonjour!"

NOT E
All options you can use with string interpolation are described in String Interpolation.

Comments
Use comments to include non-executable text in your code, as a note or reminder to
yourself. Comments are ignored by the Swift compiler when your code is compiled.
Comments in Swift are very similar to comments in C. Single-line comments begin with
two forward-slashes (//):

// this is a comment

You can also write multiline comments, which start with a forward-slash followed by an
asterisk (/*) and end with an asterisk followed by a forward-slash (*/):

/* this is also a comment,

but written over multiple lines */

Unlike multiline comments in C, multiline comments in Swift can be nested inside other
multiline comments. You write nested comments by starting a multiline comment block
and then starting a second multiline comment within the first block. The second block is
then closed, followed by the first block:

/* this is the start of the first multiline comment

/* this is the second, nested multiline comment */

this is the end of the first multiline comment */

Nested multiline comments enable you to comment out large blocks of code quickly and
easily, even if the code already contains multiline comments.
Semicolons

Unlike many other languages, Swift does not require you to write a semicolon (;) after
each statement in your code, although you can do so if you wish. Semicolons are
required, however, if you want to write multiple separate statements on a single line:

let cat = " "; println(cat)

// prints " "

Integers
Integers are whole numbers with no fractional component, such as 42 and -23. Integers
are either signed (positive, zero, or negative) or unsigned (positive or zero).
Swift provides signed and unsigned integers in 8, 16, 32, and 64 bit forms. These integers
follow a naming convention similar to C, in that an 8-bit unsigned integer is of type UInt8,
and a 32-bit signed integer is of type Int32. Like all types in Swift, these integer types
have capitalized names.

Integer Bounds
You can access the minimum and maximum values of each integer type with its min and
max properties:

let minValue = UInt8.min // minValue is equal to 0, and is of type UInt8

let maxValue = UInt8.max // maxValue is equal to 255, and is of type UInt8

The values of these properties are of the appropriate-sized number type (such as UInt8 in
the example above) and can therefore be used in expressions alongside other values of
the same type.

Int
In most cases, you don’t need to pick a specific size of integer to use in your code. Swift
provides an additional integer type, Int, which has the same size as the current platform’s
native word size:

On a 32-bit platform, Int is the same size as Int32.

On a 64-bit platform, Int is the same size as Int64.

Unless you need to work with a specific size of integer, always use Int for integer values in
your code. This aids code consistency and interoperability. Even on 32-bit platforms, Int
can store any value between -2,147,483,648 and 2,147,483,647, and is large enough for many
integer ranges.

UInt

Swift also provides an unsigned integer type, UInt, which has the same size as the current
platform’s native word size:

On a 32-bit platform, UInt is the same size as UInt32.

On a 64-bit platform, UInt is the same size as UInt64.

NOT E
Use UInt only when you specifically need an unsigned integer type with the same size as the platform’s native
word size. If this is not the case, Int is preferred, even when the values to be stored are known to be non-
negative. A consistent use of Int for integer values aids code interoperability, avoids the need to convert
between different number types, and matches integer type inference, as described in Type Safety and Type
Inference.

Floating-Point Numbers
Floating-point numbers are numbers with a fractional component, such as 3.14159, 0.1, and
-273.15.

Floating-point types can represent a much wider range of values than integer types, and
can store numbers that are much larger or smaller than can be stored in an Int. Swift
provides two signed floating-point number types:

represents a 64-bit floating-point number. Use it when floating-point values

Double
must be very large or particularly precise.
 represents a 32-bit floating-point number. Use it when floating-point values
Float
do not require 64-bit precision.

NOT E
Double has a precision of at least 15 decimal digits, whereas the precision of Float can be as little as 6 decimal
digits. The appropriate floating-point type to use depends on the nature and range of values you need to work
with in your code.

Type Safety and Type Inference

Swift is a type safe language. A type safe language encourages you to be clear about the
types of values your code can work with. If part of your code expects a String, you can’t
pass it an Int by mistake.
Because Swift is type safe, it performs type checks when compiling your code and flags
any mismatched types as errors. This enables you to catch and fix errors as early as
possible in the development process.
Type-checking helps you avoid errors when you’re working with different types of values.
However, this doesn’t mean that you have to specify the type of every constant and
variable that you declare. If you don’t specify the type of value you need, Swift uses type
inference to work out the appropriate type. Type inference enables a compiler to deduce
the type of a particular expression automatically when it compiles your code, simply by
examining the values you provide.
Because of type inference, Swift requires far fewer type declarations than languages such
as C or Objective-C. Constants and variables are still explicitly typed, but much of the
work of specifying their type is done for you.
Type inference is particularly useful when you declare a constant or variable with an
initial value. This is often done by assigning a literal value (or literal) to the constant or
variable at the point that you declare it. (A literal value is a value that appears directly in
your source code, such as 42 and 3.14159 in the examples below.)
For example, if you assign a literal value of 42 to a new constant without saying what type
it is, Swift infers that you want the constant to be an Int, because you have initialized it
with a number that looks like an integer:

let meaningOfLife = 42

// meaningOfLife is inferred to be of type Int

Likewise, if you don’t specify a type for a floating-point literal, Swift infers that you want
to create a Double:

let pi = 3.14159

// pi is inferred to be of type Double

Swift always chooses Double (rather than Float) when inferring the type of floating-point
numbers.
If you combine integer and floating-point literals in an expression, a type of Double will be
inferred from the context:

let anotherPi = 3 + 0.14159

// anotherPi is also inferred to be of type Double

The literal value of 3 has no explicit type in and of itself, and so an appropriate output
type of Double is inferred from the presence of a floating-point literal as part of the
addition.

Numeric Literals
Integer literals can be written as:

A decimal number, with no prefix

A binary number, with a 0b prefix
An octal number, with a 0o prefix
A hexadecimal number, with a 0x prefix

All of these integer literals have a decimal value of 17:

let decimalInteger = 17

let binaryInteger = 0b10001 // 17 in binary notation

let octalInteger = 0o21 // 17 in octal notation

let hexadecimalInteger = 0x11 // 17 in hexadecimal notation

Floating-point literals can be decimal (with no prefix), or hexadecimal (with a 0x prefix).

They must always have a number (or hexadecimal number) on both sides of the decimal
point. They can also have an optional exponent, indicated by an uppercase or lowercase e
for decimal floats, or an uppercase or lowercase p for hexadecimal floats.

For decimal numbers with an exponent of exp, the base number is multiplied by 10exp:

1.25e2 means 1.25 × 102, or 125.0.

1.25e-2 means 1.25 × 10-2, or 0.0125.

For hexadecimal numbers with an exponent of exp, the base number is multiplied by 2exp:

0xFp2 means 15 × 22, or 60.0.

0xFp-2 means 15 × 2-2, or 3.75.

All of these floating-point literals have a decimal value of 12.1875:

let decimalDouble = 12.1875

let exponentDouble = 1.21875e1

let hexadecimalDouble = 0xC.3p0

Numeric literals can contain extra formatting to make them easier to read. Both integers
and floats can be padded with extra zeroes and can contain underscores to help with
readability. Neither type of formatting affects the underlying value of the literal:

let paddedDouble = 000123.456

let oneMillion = 1_000_000

let justOverOneMillion = 1_000_000.000_000_1

Numeric Type Conversion

Use the Int type for all general-purpose integer constants and variables in your code, even
if they are known to be non-negative. Using the default integer type in everyday
situations means that integer constants and variables are immediately interoperable in
your code and will match the inferred type for integer literal values.
Use other integer types only when they are are specifically needed for the task at hand,
because of explicitly-sized data from an external source, or for performance, memory
usage, or other necessary optimization. Using explicitly-sized types in these situations
helps to catch any accidental value overflows and implicitly documents the nature of the
data being used.

Integer Conversion
The range of numbers that can be stored in an integer constant or variable is different for
each numeric type. An Int8 constant or variable can store numbers between -128 and 127,
whereas a UInt8 constant or variable can store numbers between 0 and 255. A number that
will not fit into a constant or variable of a sized integer type is reported as an error when
your code is compiled:

let cannotBeNegative: UInt8 = -1

// UInt8 cannot store negative numbers, and so this will report an error

let tooBig: Int8 = Int8.max + 1

// Int8 cannot store a number larger than its maximum value,

// and so this will also report an error

Because each numeric type can store a different range of values, you must opt in to
numeric type conversion on a case-by-case basis. This opt-in approach prevents hidden
conversion errors and helps make type conversion intentions explicit in your code.
To convert one specific number type to another, you initialize a new number of the
desired type with the existing value. In the example below, the constant twoThousand is of
type UInt16, whereas the constant one is of type UInt8. They cannot be added together
directly, because they are not of the same type. Instead, this example calls UInt16(one) to
create a new UInt16 initialized with the value of one, and uses this value in place of the
original:

let twoThousand: UInt16 = 2_000

let one: UInt8 = 1

let twoThousandAndOne = twoThousand + UInt16(one)

Because both sides of the addition are now of type UInt16, the addition is allowed. The
output constant (twoThousandAndOne) is inferred to be of type UInt16, because it is the sum of
two UInt16 values.
is the default way to call the initializer of a Swift type and pass in an
SomeType(ofInitialValue)
initial value. Behind the scenes, UInt16 has an initializer that accepts a UInt8 value, and so
this initializer is used to make a new UInt16 from an existing UInt8. You can’t pass in any
type here, however—it has to be a type for which UInt16 provides an initializer. Extending
existing types to provide initializers that accept new types (including your own type
definitions) is covered in Extensions.

Integer and Floating-Point Conversion

Conversions between integer and floating-point numeric types must be made explicit:

let three = 3

let pointOneFourOneFiveNine = 0.14159

let pi = Double(three) + pointOneFourOneFiveNine

// pi equals 3.14159, and is inferred to be of type Double

Here, the value of the constant three is used to create a new value of type Double, so that
both sides of the addition are of the same type. Without this conversion in place, the
addition would not be allowed.
The reverse is also true for floating-point to integer conversion, in that an integer type
can be initialized with a Double or Float value:

let integerPi = Int(pi)

// integerPi equals 3, and is inferred to be of type Int

Floating-point values are always truncated when used to initialize a new integer value in
this way. This means that 4.75 becomes 4, and -3.9 becomes -3.

NOT E
The rules for combining numeric constants and variables are different from the rules for numeric literals. The
literal value 3 can be added directly to the literal value 0.14159, because number literals do not have an explicit
type in and of themselves. Their type is inferred only at the point that they are evaluated by the compiler.

Type Aliases
Type aliases define an alternative name for an existing type. You define type aliases with
the typealias keyword.
Type aliases are useful when you want to refer to an existing type by a name that is
contextually more appropriate, such as when working with data of a specific size from an
external source:

typealias AudioSample = UInt16

Once you define a type alias, you can use the alias anywhere you might use the original
name:

var maxAmplitudeFound = AudioSample.min

// maxAmplitudeFound is now 0

Here, AudioSample is defined as an alias for UInt16. Because it is an alias, the call to
AudioSample.min actually calls UInt16.min, which provides an initial value of 0 for the
maxAmplitudeFound variable.

Booleans
Swift has a basic Boolean type, called Bool. Boolean values are referred to as logical,
because they can only ever be true or false. Swift provides two Boolean constant values,
true and false:

let orangesAreOrange = true

let turnipsAreDelicious = false

The types of orangesAreOrange and turnipsAreDelicious have been inferred as Bool from the fact that
they were initialized with Boolean literal values. As with Int and Double above, you don’t
need to declare constants or variables as Bool if you set them to true or false as soon as you
create them. Type inference helps make Swift code more concise and readable when it
initializes constants or variables with other values whose type is already known.
Boolean values are particularly useful when you work with conditional statements such as
the if statement:

if turnipsAreDelicious {

println("Mmm, tasty turnips!")

} else {

println("Eww, turnips are horrible.")

// prints "Eww, turnips are horrible."

Conditional statements such as the if statement are covered in more detail in Control
Flow.
Swift’s type safety prevents non-Boolean values from being be substituted for Bool. The
following example reports a compile-time error:

let i = 1

if i {

// this example will not compile, and will report an error

However, the alternative example below is valid:

let i = 1

if i == 1 {

// this example will compile successfully

The result of the i == 1 comparison is of type Bool, and so this second example passes the
type-check. Comparisons like i == 1 are discussed in Basic Operators.
As with other examples of type safety in Swift, this approach avoids accidental errors and
ensures that the intention of a particular section of code is always clear.

Tuples
Tuples group multiple values into a single compound value. The values within a tuple can
be of any type and do not have to be of the same type as each other.
In this example, (404, "Not Found") is a tuple that describes an HTTP status code. An HTTP
status code is a special value returned by a web server whenever you request a web
page. A status code of 404 Not Found is returned if you request a webpage that doesn’t exist.

let http404Error = (404, "Not Found")

// http404Error is of type (Int, String), and equals (404, "Not Found")

The (404, "Not Found") tuple groups together an Int and a String to give the HTTP status code
two separate values: a number and a human-readable description. It can be described as
“a tuple of type (Int, String)”.
You can create tuples from any permutation of types, and they can contain as many
different types as you like. There’s nothing stopping you from having a tuple of type (Int,
Int, Int), or (String, Bool), or indeed any other permutation you require.

You can decompose a tuple’s contents into separate constants or variables, which you
then access as usual:

let (statusCode, statusMessage) = http404Error

println("The status code is \(statusCode)")

// prints "The status code is 404"

println("The status message is \(statusMessage)")

// prints "The status message is Not Found"

If you only need some of the tuple’s values, ignore parts of the tuple with an underscore
(_) when you decompose the tuple:

let (justTheStatusCode, _) = http404Error

println("The status code is \(justTheStatusCode)")

// prints "The status code is 404"

Alternatively, access the individual element values in a tuple using index numbers
starting at zero:

println("The status code is \(http404Error.0)")

// prints "The status code is 404"

println("The status message is \(http404Error.1)")

// prints "The status message is Not Found"

You can name the individual elements in a tuple when the tuple is defined:

let http200Status = (statusCode: 200, description: "OK")

If you name the elements in a tuple, you can use the element names to access the values
of those elements:

println("The status code is \(http200Status.statusCode)")

// prints "The status code is 200"

println("The status message is \(http200Status.description)")

 // prints "The status message is OK"

Tuples are particularly useful as the return values of functions. A function that tries to
retrieve a web page might return the (Int, String) tuple type to describe the success or
failure of the page retrieval. By returning a tuple with two distinct values, each of a
different type, the function provides more useful information about its outcome than if it
could only return a single value of a single type. For more information, see Functions with
Multiple Return Values.

NOT E
Tuples are useful for temporary groups of related values. They are not suited to the creation of complex data
structures. If your data structure is likely to persist beyond a temporary scope, model it as a class or
structure, rather than as a tuple. For more information, see Classes and Structures.

Optionals
You use optionals in situations where a value may be absent. An optional says:

There is a value, and it equals x

or

There isn’t a value at all

NOT E
The concept of optionals doesn’t exist in C or Objective-C. The nearest thing in Objective-C is the ability to
return nil from a method that would otherwise return an object, with nil meaning “the absence of a valid
object.” However, this only works for objects—it doesn’t work for structs, basic C types, or enumeration
values. For these types, Objective-C methods typically return a special value (such as NSNotFound) to
indicate the absence of a value. This approach assumes that the method’s caller knows there is a special
value to test against and remembers to check for it. Swift’s optionals let you indicate the absence of a value
for any type at all, without the need for special constants.

Here’s an example. Swift’s String type has a method called toInt, which tries to convert a
String value into an Int value. However, not every string can be converted into an integer.
The string "123" can be converted into the numeric value 123, but the string "hello, world" does
not have an obvious numeric value to convert to.
The example below uses the toInt method to try to convert a String into an Int:

let possibleNumber = "123"

let convertedNumber = possibleNumber.toInt()

// convertedNumber is inferred to be of type "Int?", or "optional Int"

Because the toInt method might fail, it returns an optional Int, rather than an Int. An
optional Int is written as Int?, not Int. The question mark indicates that the value it contains
is optional, meaning that it might contain some Int value, or it might contain no value at
all. (It can’t contain anything else, such as a Bool value or a String value. It’s either an Int, or
it’s nothing at all.)

If Statements and Forced Unwrapping

You can use an if statement to find out whether an optional contains a value. If an
optional does have a value, it evaluates to true; if it has no value at all, it evaluates to
false.

Once you’re sure that the optional does contain a value, you can access its underlying
value by adding an exclamation mark (!) to the end of the optional’s name. The
exclamation mark effectively says, “I know that this optional definitely has a value;
please use it.” This is known as forced unwrapping of the optional’s value:

if convertedNumber {

println("\(possibleNumber) has an integer value of \(convertedNumber!)")

} else {

println("\(possibleNumber) could not be converted to an integer")

// prints "123 has an integer value of 123"

For more on the if statement, see Control Flow.

NOT E
Trying to use ! to access a non-existent optional value triggers a runtime error. Always make sure that an
optional contains a non-nil value before using ! to force-unwrap its value.
Optional Binding
You use optional binding to find out whether an optional contains a value, and if so, to
make that value available as a temporary constant or variable. Optional binding can be
used with if and while statements to check for a value inside an optional, and to extract
that value into a constant or variable, as part of a single action. if and while statements are
described in more detail in Control Flow.
Write optional bindings for the if statement as follows:

if let constantName = someOptional {

statements

You can rewrite the possibleNumber example from above to use optional binding rather than
forced unwrapping:

if let actualNumber = possibleNumber.toInt() {

println("\(possibleNumber) has an integer value of \(actualNumber)")

} else {

println("\(possibleNumber) could not be converted to an integer")

// prints "123 has an integer value of 123"

This can be read as:

“If the optional Int returned by possibleNumber.toInt contains a value, set a new constant called
actualNumber to the value contained in the optional.”

If the conversion is successful, the actualNumber constant becomes available for use within
the first branch of the if statement. It has already been initialized with the value
contained within the optional, and so there is no need to use the ! suffix to access its
value. In this example, actualNumber is simply used to print the result of the conversion.
You can use both constants and variables with optional binding. If you wanted to
manipulate the value of actualNumber within the first branch of the if statement, you could
write if var actualNumber instead, and the value contained within the optional would be made
available as a variable rather than a constant.
nil
You set an optional variable to a valueless state by assigning it the special value nil:

var serverResponseCode: Int? = 404

// serverResponseCode contains an actual Int value of 404

serverResponseCode = nil

// serverResponseCode now contains no value

NOT E
nil cannot be used with non-optional constants and variables. If a constant or variable in your code needs to
be able to cope with the absence of a value under certain conditions, always declare it as an optional value of
the appropriate type.

If you define an optional constant or variable without providing a default value, the
constant or variable is automatically set to nil for you:

var surveyAnswer: String?

// surveyAnswer is automatically set to nil

NOT E
Swift’s nil is not the same as nil in Objective-C. In Objective-C, nil is a pointer to a non-existent object. In
Swift, nil is not a pointer—it is the absence of a value of a certain type. Optionals of any type can be set to nil,
not just object types.

Implicitly Unwrapped Optionals

As described above, optionals indicate that a constant or variable is allowed to have “no
value”. Optionals can be checked with an if statement to see if a value exists, and can be
conditionally unwrapped with optional binding to access the optional’s value if it does
exist.
Sometimes it is clear from a program’s structure that an optional will always have a
value, after that value is first set. In these cases, it is useful to remove the need to check
and unwrap the optional’s value every time it is accessed, because it can be safely
assumed to have a value all of the time.
These kinds of optionals are defined as implicitly unwrapped optionals. You write an
implicitly unwrapped optional by placing an exclamation mark (String!) rather than a
question mark (String?) after the type that you want to make optional.
Implicitly unwrapped optionals are useful when an optional’s value is confirmed to exist
immediately after the optional is first defined and can definitely be assumed to exist at
every point thereafter. The primary use of implicitly unwrapped optionals in Swift is
during class initialization, as described in Unowned References and Implicitly Unwrapped
Optional Properties.
An implicitly unwrapped optional is a normal optional behind the scenes, but can also be
used like a nonoptional value, without the need to unwrap the optional value each time it
is accessed. The following example shows the difference in behavior between an optional
String and an implicitly unwrapped optional String:

let possibleString: String? = "An optional string."

println(possibleString!) // requires an exclamation mark to access its value

// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."

println(assumedString) // no exclamation mark is needed to access its value

// prints "An implicitly unwrapped optional string."

You can think of an implicitly unwrapped optional as giving permission for the optional to
be unwrapped automatically whenever it is used. Rather than placing an exclamation
mark after the optional’s name each time you use it, you place an exclamation mark after
the optional’s type when you declare it.

NOT E
If you try to access an implicitly unwrapped optional when it does not contain a value, you will trigger a runtime
error. The result is exactly the same as if you place an exclamation mark after a normal optional that does
not contain a value.

You can still treat an implicitly unwrapped optional like a normal optional, to check if it
contains a value:

if assumedString {
 println(assumedString)

// prints "An implicitly unwrapped optional string."

You can also use an implicitly unwrapped optional with optional binding, to check and
unwrap its value in a single statement:

if let definiteString = assumedString {

println(definiteString)

// prints "An implicitly unwrapped optional string."

NOT E
Implicitly unwrapped optionals should not be used when there is a possibility of a variable becoming nil at a
later point. Always use a normal optional type if you need to check for a nil value during the lifetime of a
variable.

Assertions
Optionals enable you to check for values that may or may not exist, and to write code
that copes gracefully with the absence of a value. In some cases, however, it is simply
not possible for your code to continue execution if a value does not exist, or if a provided
value does not satisfy certain conditions. In these situations, you can trigger an assertion
in your code to end code execution and to provide an opportunity to debug the cause of
the absent or invalid value.

Debugging with Assertions

An assertion is a runtime check that a logical condition definitely evaluates to true.
Literally put, an assertion “asserts” that a condition is true. You use an assertion to make
sure that an essential condition is satisfied before executing any further code. If the
condition evaluates to true, code execution continues as usual; if the condition evaluates
to false, code execution ends, and your app is terminated.
If your code triggers an assertion while running in a debug environment, such as when
you build and run an app in Xcode, you can see exactly where the invalid state occurred
and query the state of your app at the time that the assertion was triggered. An assertion
also lets you provide a suitable debug message as to the nature of the assert.
You write an assertion by calling the global assert function. You pass the assert function an
expression that evaluates to true or false and a message that should be displayed if the
result of the condition is false:

let age = -3

assert(age >= 0, "A person's age cannot be less than zero")

// this causes the assertion to trigger, because age is not >= 0

In this example, code execution will continue only if age >= 0 evaluates to true, that is, if
the value of age is non-negative. If the value of age is negative, as in the code above, then
age >= 0 evaluates to false, and the assertion is triggered, terminating the application.

Assertion messages cannot use string interpolation. The assertion message can be
omitted if desired, as in the following example:

assert(age >= 0)

When to Use Assertions

Use an assertion whenever a condition has the potential to be false, but must definitely
be true in order for your code to continue execution. Suitable scenarios for an assertion
check include:

An integer subscript index is passed to a custom subscript implementation, but the

subscript index value could be too low or too high.
A value is passed to a function, but an invalid value means that the function
cannot fulfill its task.
An optional value is currently nil, but a non-nil value is essential for subsequent
code to execute successfully.

See also Subscripts and Functions.

NOT E
Assertions cause your app to terminate and are not a substitute for designing your code in such a way that
invalid conditions are unlikely to arise. Nonetheless, in situations where invalid conditions are possible, an
assertion is an effective way to ensure that such conditions are highlighted and noticed during development,
before your app is published.
Basic Operators

An operator is a special symbol or phrase that you use to check, change, or combine
values. For example, the addition operator (+) adds two numbers together (as in let i = 1 +
2). More complex examples include the logical AND operator && (as in if enteredDoorCode &&
passedRetinaScan) and the increment operator ++i, which is a shortcut to increase the value of
i by 1.

Swift supports most standard C operators and improves several capabilities to eliminate
common coding errors. The assignment operator (=) does not return a value, to prevent it
from being mistakenly used when the equal to operator (==) is intended. Arithmetic
operators (+, -, *, /, % and so forth) detect and disallow value overflow, to avoid
unexpected results when working with numbers that become larger or smaller than the
allowed value range of the type that stores them. You can opt in to value overflow
behavior by using Swift’s overflow operators, as described in Overflow Operators.
Unlike C, Swift lets you perform remainder (%) calculations on floating-point numbers.
Swift also provides two range operators (a..b and a...b) not found in C, as a shortcut for
expressing a range of values.
This chapter describes the common operators in Swift. Advanced Operators covers Swift’s
advanced operators, and describes how to define your own custom operators and
implement the standard operators for your own custom types.

Terminology
Operators are unary, binary, or ternary:

Unary operators operate on a single target (such as -a). Unary prefix operators
appear immediately before their target (such as !b), and unary postfix operators
appear immediately after their target (such as i++).
Binary operators operate on two targets (such as 2 + 3) and are infix because they
appear in between their two targets.
Ternary operators operate on three targets. Like C, Swift has only one ternary
operator, the ternary conditional operator (a ? b : c).

The values that operators affect are operands. In the expression 1 + 2, the + symbol is a
binary operator and its two operands are the values 1 and 2.
Assignment Operator

The assignment operator (a = b) initializes or updates the value of a with the value of b:

let b = 10

var a = 5

a=b

// a is now equal to 10

If the right side of the assignment is a tuple with multiple values, its elements can be
decomposed into multiple constants or variables at once:

let (x, y) = (1, 2)

// x is equal to 1, and y is equal to 2

Unlike the assignment operator in C and Objective-C, the assignment operator in Swift
does not itself return a value. The following statement is not valid:

if x = y {

// this is not valid, because x = y does not return a value

This feature prevents the assignment operator (=) from being used by accident when the
equal to operator (==) is actually intended. By making if x = y invalid, Swift helps you to
avoid these kinds of errors in your code.

Arithmetic Operators
Swift supports the four standard arithmetic operators for all number types:

Addition (+)
Subtraction (-)
Multiplication (*)
Division (/)
 Another Random Document on
Scribd Without Any Related Topics
object you name, it possesses existence. Consequently, He who is
supremely simple cannot think Himself; if He did, He would be
somewhere, (which is not the case). Therefore He does not think,
and He cannot be grasped by thought.

WE COME SUFFICIENTLY NEAR TO HIM TO TALK

ABOUT HIM.
14. How then do we speak of Him? Because we can assert
something about Him, though we cannot express Him by speech. We
could not know Him, nor grasp Him by thought. How then do we
speak of Him, if we cannot grasp Him? Because though He does
escape our knowledge, He does not escape us completely. We grasp
Him enough to assert something about Him without expressing Him
himself, to say what He is not, without saying what He is; that is
why in speaking of Him we use terms that are suitable to designate
only lower things. Besides we can embrace Him without being
capable of expressing Him, like men who, transported by a divine
enthusiasm, feel that they contain something superior without being
able to account for it. They speak of what agitates them, and they
thus have some feeling of Him who moves them, though they differ
therefrom. Such is our relation with Him; when we rise to Him by
using our pure intelligence, we feel that He is the foundation of our
intelligence, the principle that furnishes "being" and other things of
the kind; we feel that He is better, greater, and more elevated than
we, because He is superior to reason, to intelligence, and to the
senses, because He gives these things without being what they are.

RADIATION OF MULTIPLE UNITY.

15. How does He give them? Is it because He possesses them,
or because He does not possess them? If it be because He does not
possess them, how does He give what He does not possess? If it be
because He does possess them, He is no longer simple. If He give
what He does not possess, how is multiplicity born of Him? It would
seem as if only one single thing could proceed from Him, unity; and
even so one might wonder how anything whatever could be born of
that which is absolutely one. We answer, in the same way as from a
light radiates a luminous sphere (or, fulguration109). But how can the
manifold be born from the One? Because the thing that proceeds
from Him must not be equal to Him, and so much the less, superior;
for what is superior to unity, or better than Him? It must, therefore,
be inferior to Him, and, consequently, be less perfect. Now it cannot
be less perfect, except on condition of being less unitary, that is,
more manifold. But as it must aspire to unity, it will be the "manifold
one." It is by that which is single that that which is not single is
preserved, and is what it is; for that which is not one, though
composite, cannot receive the name of existence. If it be possible to
say what each thing is, it is only because it is one and identical.
What is not manifold is not one by participation, but is absolute
unity; it does not derive its unity from any other principle; on the
contrary it is the principle to which other things owe that they are
more or less single, according as they are more or less close to it.
Since the characteristic of that which is nearest to unity is identity,
and is posterior to unity, evidently the manifoldness contained
therein, must be the totality of things that are single. For since
manifoldness is therein united with manifoldness, it does not contain
parts separated from each other, and all subsist together. Each of the
things, that proceed therefrom, are manifold unity, because they
cannot be universal unity. Universal unity is characteristic only of
their principle (the intelligible Being), because itself proceeds from a
great Principle which is one, essentially, and genuinely. That which,
by its exuberant fruitfulness, begets, is all; on the other hand, as this
totality participates in unity, it is single; and, consequently, it is
single totality (universal unity).

THE SUPREME PRODUCES MANIFOLDNESS BECAUSE

OF ITS CATEGORIES.
 We have seen that existence is "all these things;" now, what are
they? All those of which the One is the principle. But how can the
One be the principle of all things? Because the One preserves their
existence while effecting the individuality of each of them. Is it also
because He gives them existence? And if so, does He do so by
possessing them? In this case, the One would be manifold. No, it is
by containing them without any distinction yet having arisen among
them. On the contrary, in the second principle they are distinguished
by reason; that is, they are logically distinguished, because this
second principle is an actualization, while the first Principle is the
power-potentiality107 of all things; not in the sense in which we say
that matter is potential in that it receives, or suffers, but in the
opposite sense that the One produces. How then can the One
produce what it does not possess, since unity produces that neither
by chance nor by reflection? We have already said that what
proceeds from unity must differ from it; and, consequently, cannot
be absolutely one; that it must be duality, and, consequently,
multitude, since it will contain (the categories, such as) identity, and
difference, quality, and so forth.110 We have demonstrated that that
which is born of the One is not absolutely one. It now remains for us
to inquire whether it will be manifold, such as it is seen to be in what
proceeds from the One. We shall also have to consider why it
necessarily proceeds from the One.

THE GOOD MUST BE SUPERIOR TO INTELLIGENCE

AND LIFE.
16. We have shown elsewhere that something must follow the
One, and that the One is a power, and is inexhaustible; and this is
so, because even the last-rank entities possess the power of
begetting. For the present we may notice that the generation of
things reveals a descending procession, in which, the further we go,
the more does manifoldness increase; and that the principle is
always simpler than the things it produces.111 Therefore, that which
has produced the sense world is not the sense-world itself, but
Intelligence and the intelligible world; and that which has begotten
Intelligence and the intelligible world is neither Intelligence nor the
intelligible world, but something simpler than them. Manifoldness is
not born of manifoldness, but of something that is not manifold. If
That which was superior to Intelligence were manifold, it would no
longer be the (supreme) Principle, and we would have to ascend
further. Everything must, therefore, be reduced to that which is
essentially one, which is outside of all manifoldness; and whose
simplicity is the greatest possible. But how can manifold and
universal Reason be born of the One, when very evidently the One is
not a reason? As it is not a reason, how can it beget Reason? How
can the Good beget a hypostatic form of existence, which would be
good in form? What does this hypostatic form of existence possess?
Is it identity? But what is the relation between identity and
goodness? Because as soon as we possess the Good, we seek
identity and permanence; and because the Good is the principle
from which we must not separate; for if it were not the Good, it
would be better to give it up. We must, therefore, wish to remain
united to the Good. Since that is the most desirable for Intelligence,
it need seek nothing beyond, and its permanence indicates its
satisfaction with the entities it possesses. Enjoying, as it does, their
presence in a manner such that it fuses with them, it must then
consider life as the most precious entity of all. As Intelligence
possesses life in its universality and fulness, this life is the fulness
and universality of the Soul and Intelligence. Intelligence, therefore,
is self-sufficient, and desires nothing; it contains what it would have
desired if it had not already possessed such desirable object. It
possesses the good that consists in life and intelligence, as we have
said, or in some one of the connected entities. If Life and
Intelligence were the absolute Good, there would be nothing above
them. But if the absolute Good be above them, the good of
Intelligence is this Life, which relates to the absolute Good, which
connects with it, which receives existence from it, and rises towards
it, because it is its principle. The Good, therefore, must be superior
to Life and Intelligence. On this condition only does the life of
Intelligence, the image of Him from whom all life proceeds, turn
towards Him; on this condition only does Intelligence, the imitation
of the contents of the One, whatever be His nature, turn towards
Him.

THE SUPREME AS SUPERESSENTIAL AND

SUPEREXISTENT.
17. What better thing is there then than this supremely wise Life,
exempt from all fault or error? What is there better than the
Intelligence that embraces everything? In one word, what is there
better than universal Life and universal Intelligence? If we answer
that what is better than these things is the Principle that begat
them, if we content ourselves with explaining how it begat them,
and to show that one cannot discover anything better, we shall,
instead of progressing in this discussion, ever remain at the same
point. Nevertheless, we need to rise higher. We are particularly
obliged to do this, when we consider that the principle that we seek
must be considered as the "Self-sufficient supremely independent of
all things;" for no entity is able to be self-sufficient, and all have
participated in the One; and since they have done so, none of them
can be the One. Which then is this principle in which all participate,
which makes Intelligence exist, and is all things? Since it makes
Intelligence exist, and since it is all things, since it makes its
contained manifoldness self-sufficient by the presence of unity, and
since it is thus the creative principle of "being" and self-sufficiency, it
must, instead of being "being," be super-"being" and super-
existence.

ECSTASY IS INTELLECTUAL CONTACT WITH

SUDDEN LIGHT.
 Have we said enough, and can we stop here? Or does our soul
still feel the pains of parturition? Let her, therefore, produce
(activity), rushing towards the One, driven by the pains that agitate
her. No, let us rather seek to calm her by some magic charm, if any
remedy therefor exist. But to charm the soul, it may perhaps be
sufficient to repeat what we have already said. To what other charm,
indeed, would it suffice to have recourse? Rising above all the truths
in which we participate, this enchantment evanesces the moment we
speak, or even think. For, in order to express something, discursive
reason is obliged to go from one thing to another, and successively
to run through every element of its object. Now what can be
successively scrutinized in that which is absolutely simple? It is,
therefore, sufficient to reach Him by a sort of intellectual contact.
Now at the moment of touching the One, we should neither be able
to say anything about Him, nor have the leisure to speak of Him;
only later is it possible to argue about Him. We should believe that
we have seen Him when a sudden light has enlightened the soul; for
this light comes from Him, and is Himself. We should believe that He
is present when, as another (lower) divinity, He illumines the house
of him who calls on this divinity,112 for it remains obscure without
the illumination of the divinity. The soul, therefore, is without light
when she is deprived of the presence of this divinity, when illumined
by this divinity, she has what she sought. The true purpose of the
soul is to be in contact with this light, to see this light in the radiance
of this light itself, without the assistance of any foreign light, to see
this principle by the help of which she sees. Indeed, it is the
principle by which she is enlightened that she must contemplate as
one gazes at the sun only through its own light. But how shall we
succeed in this? By cutting off everything else.113
 THIRD ENNEAD, BOOK FIVE.114
Of Love, or "Eros."

LOVE AS GOD, GUARDIAN AND PASSION.

1. Is Love a divinity, a guardian, or a passion of the human soul?
Or is it all three under different points of view? In this case, what is
it under each of these points of view? These are the questions we
are to consider, consulting the opinions of men, but chiefly those of
the philosophers. The divine Plato, who has written much about
love, here deserves particular attention. He says that it is not only a
passion capable of being born in souls, but he calls it also a
guardian, and he gives many details about its birth and parents.115

PASSIONAL LOVE IS TWOFOLD.

To begin with passion, it is a matter of common knowledge that
the passion designated as love is born in the souls which desire to
unite themselves to a beautiful object. But its object may be either a
shameful practice, or one (worthy to be pursued by) temperate men,
who are familiar with beauty. We must, therefore, investigate in a
philosophical manner what is the origin of both kinds of love.

LOVE IS RECOGNITION OF HIDDEN AFFINITY.

The real cause of love is fourfold: the desire of beauty; our
soul's innate notion of beauty; our soul's affinity with beauty, and
our soul's instinctive sentiment of this affinity.116 (Therefore as
beauty lies at the root of love, so) ugliness is contrary to nature and
divinity. In fact, when Nature wants to create, she contemplates
what is beautiful, determinate, and comprehended within the
(Pythagorean) "sphere" of the Good. On the contrary, the
(Pythagorean) "indeterminate"115 is ugly, and belongs to the other
system.117 Besides, Nature herself owes her origin to the Good, and,
therefore, also to the Beautiful. Now, as soon as one is attracted by
an object, because one is united to it by a secret affinity, he
experiences for the images of this object a sentiment of sympathy.
We could not explain its origin, or assign its cause on any other
hypothesis, even were we to limit ourselves to the consideration of
physical love. Even this kind of love is a desire to procreate
beauty,118 for it would be absurd to insist that that Nature, which
aspires to create beautiful things, should aspire to procreate that
which is ugly.

EARTHLY BEAUTY IS AN IMAGE OF INTELLIGIBLE

BEAUTY.
Of course, those who, here below, desire to procreate are
satisfied in attaining that which is beautiful here below: namely, the
beauty which shines in images and bodies; for they do not possess
that intelligible Beauty which, nevertheless, inspires them with that
very love which they bear to visible beauty. That is the reason why
those who ascend to the reminiscence of intelligible Beauty love that
which they behold here below only because it is an image of the
other.119 As to those who fail to rise to the reminiscence of the
intelligible Beauty, because they do not know the cause of their
passion, they mistake visible beauty for that veritable Beauty, and
they may even love it chastely, if they be temperate: but to go as far
as a carnal union is an error, in any case. Hence, it happens that
only he who is inspired by a pure love for the beautiful really loves
beauty, whether or not he have aroused his reminiscence of
intelligible Beauty.

BEAUTY IS IMMORTAL.
They who join to this passion as much of a desire for immortality
as our mortal nature admits, seek beauty in the perpetuity of the
procreation which renders man imperishable. They determine to
procreate and produce beauty according to nature; procreating
because their object is perpetuity; and procreating beautifully
because they possess affinity with it. In fact, perpetuity does bear
affinity to beauty; perpetual nature is beauty itself; and such also
are all its derivatives.

PASSIONAL LOVE MAY BE ELEVATING, THOUGH

OPEN TO MISLEADING TEMPTATIONS.
Thus he who does not desire to procreate seems to aspire to the
possession of the beautiful in a higher degree. He who desires to
procreate does no doubt desire to procreate the beautiful; but his
desire indicates in him the presence of need, and dissatisfaction with
mere possession of beauty; He thinks he will be procreating beauty,
if he begets on that which is beautiful. They who wish to satisfy
physical love against human laws, and nature, no doubt have a
natural inclination as principle of a triple passion; but they lose their
way straying from the right road for lack of knowledge of the end to
which love was impelling them, of the goal of the aspiration (roused
by) the desire of generation, and of the proper use of the image of
beauty.120 They really do ignore Beauty itself. They who love
beautiful bodies without desiring to unite themselves to them, love
them for their beauty only. Those who love the beauty of women,
and desire union with them, love both beauty and perpetuity, so long
as this object is not lost from sight. Both of these are temperate, but
they who love bodies for their beauty only are the more virtuous.
The former admire sensual beauty, and are content therewith; the
latter recall intelligible beauty, but, without scorning visible beauty,
regard it as an effect and image of the intelligible Beauty.121 Both,
therefore, love beauty without ever needing to blush. But, as to
those (who violate laws human and divine), love of beauty misleads
them to falling into ugliness; for the desire of good may often
mislead to a fall into evil. Such is love considered as a passion of the
soul.

THE PLATONIC MYTH OF LOVE.

2. Now let us speak of the Love which is considered a deity not
only by men in general, but also by the (Orphic) theologians, and by
Plato. The latter often speaks of Love, son of Venus, attributing to
him the mission of being the chief of the beautiful children (or,
boys); and to direct souls to the contemplation of intelligible Beauty,
or, if already present, to intensify the instinct to seek it. In his
"Banquet" Plato says that Love is born (not of Venus, but) of
Abundance and Need,122 ... on some birthday (?) of Venus.

INTERPRETATION OF THE PLATONIC MYTH.

To explain if Love be born of Venus, or if he were only born
contemporaneously with his mother, we shall have to study
something about Venus. What is Venus? Is she the mother of Love,
or only his contemporary? As answer hereto we shall observe that
there are two Venuses.123 The second (or Popular Venus) is
daughter of Jupiter and Dione, and she presides over earthly
marriages. The first Venus, the celestial one, daughter of Uranus (by
Plato, in his Cratylus, interpreted to mean "contemplation of things
above"), has no mother, and does not preside over marriages, for
the reason that there are none in heaven. The Celestial Venus,
therefore, daughter of Kronos,124 that is, of Intelligence, is the divine
Soul, which is born pure of pure Intelligence, and which dwells
above.125 As her nature does not admit of inclining earthward, she
neither can nor will descend here below. She is, therefore, a form of
existence (or, an hypostasis), separated from matter, not
participating in its nature. This is the significance of the allegory that
she had no mother. Rather than a guardian, therefore, she should be
considered a deity, as she is pure Being unmingled (with matter),
and abiding within herself.

LOVE, LIKE HIGHER SOUL, OR LIGHT, IS

INSEPARABLE FROM ITS SOURCE.
In fact, that which is immediately born of Intelligence is pure in
itself, because, by its very proximity to Intelligence, it has more
innate force, desiring to unite itself firmly to the principle that begat
it, and which can retain it there on high. The soul which is thus
suspended to Intelligence could not fall down, any more than the
light which shines around the sun could separate from the body from
which it radiates, and to which it is attached.

WHO CELESTIAL VENUS IS.

Celestial Venus (the universal Soul, the third principle or
hypostasis126), therefore, attaches herself to Kronos (divine
Intelligence, the second principle), or, if you prefer to Uranos (the
One, the Good, the first Principle), the father of Kronos. Thus Venus
turns towards Uranos, and unites herself to him; and in the act of
loving him, she procreates Love, with which she contemplates
Uranus. Her activity thus effects a hypostasis and being. Both of
them therefore fix their gaze on Uranus, both the mother and the
fair child, whose nature it is to be a hypostasis ever turned towards
another beauty, an intermediary essence between the lover and the
beloved object. In fact, Love is the eye by which the lover sees the
beloved object; anticipating her, so to speak; and before giving her
the faculty of seeing by the organ which he thus constitutes, he
himself is already full of the spectacle offered to his contemplation.
Though he thus anticipates her, he does not contemplate the
intelligible in the same manner as she does, in that he offers her the
spectacle of the intelligible, and that he himself enjoys the vision of
the beautiful, a vision that passes by him (or, that coruscates around
him, as an aureole).

LOVE POSSESSES DIVINE BEING.

3. We are therefore forced to acknowledge that Love is a
hypostasis and is "being," which no doubt is inferior to the Being
from which it (emanates, that is, from celestial Venus, or the
celestial Soul), but which, nevertheless, still possesses "being." In
fact, that celestial Soul is a being born of the activity which is
superior to her (the primary Being), a living Being, emanating from
the primary Being, and attached to the contemplation thereof. In it
she discovers the first object of her contemplation, she fixes her
glance on it, as her good; and finds in this view a source of joy. The
seen object attracts her attention so that, by the joy she feels, by
the ardent attention characterizing her contemplation of its object,
she herself begets something worthy of her and of the spectacle she
enjoys. Thus is Love born from the attention with which the soul
applies herself to the contemplation of its object, and from the very
emanation of this object; and so Love is an eye full of the object it
contemplates, a vision united to the image which it forms. Thus Love
(Eros) seems to owe its name to its deriving its existence from
vision.127 Even when considered as passion does Love owe its name
to the same fact, for Love-that-is-a-being is anterior to Love-that-is-
not-a-being. However much we may explain passion as love, it is,
nevertheless, ever the love of some object, and is not love in an
absolute sense.

CELESTIAL LOVE MUST ABIDE IN THE INTELLIGIBLE

WITH THE CELESTIAL SOUL.
 Such is the love that characterizes the superior Soul (the
celestial Soul). It contemplates the intelligible world with it, because
Love is the Soul's companion, being born of the Soul, and abiding in
the Soul, and with her enjoys contemplation of the divinities. Now as
we consider the Soul which first radiates its light on heaven as
separate from matter, we must admit that the love which is
connected with her, is likewise separate from matter. If we say that
this pure Soul really resides in heaven, it is in the sense in which we
say that that which is most precious in us (the reasonable soul)
resides in our body, and, nevertheless, is separate from matter. This
love must, therefore, reside only there where resides this pure Soul.

THERE IS A LOWER LOVE, CORRESPONDING TO

THE WORLD-SOUL.
But as it was similarly necessary that beneath the celestial Soul
there should exist the world-Soul,128 there must exist with it another
love, born of her desire, and being her eye.129 As this Venus belongs
to this world, and as it is not the pure soul, nor soul in an absolute
sense, it has begotten the Love which reigns here below, and which,
with her, presides over marriages. As far as this Love himself feels
the desire for the intelligible, he turns towards the intelligible the
souls of the young people, and he elevates the soul to which he may
be united, as far as it is naturally disposed to have reminiscence of
the intelligible. Every soul, indeed, aspires to the Good, even that
soul that is mingled with matter, and that is the soul of some
particular being; for it is attached to the superior Soul, and proceeds
therefrom.

ALL SOULS HAVE THEIR LOVE, WHICH IS THEIR

GUARDIAN.
 4. Does each soul include such a love in her being, and possess
it as a hypostatic (form of existence)? Since the world-Soul
possesses, as hypostasis (form of existence), the Love which is
inherent in her being, our soul should also similarly possess, as
hypostatic (form of existence), a love equally inherent in our being.
Why should the same not obtain even with animals? This love
inherent to the being of every soul is the guardian considered to be
attached to each individual.130 It inspires each soul with the desires
natural for her to experience; for, according to her nature, each soul
begets a love which harmonizes with her dignity and being. As the
universal Soul possesses universal Love, so do individual souls each
possess her individual love. But as the individual souls are not
separated from the universal Soul, and are so contained within her
that their totality forms but a single soul,131 so are individual loves
contained within the universal Love. On the other hand, each
individual love is united to an individual soul, as universal Love is
united to the universal Soul. The latter exists entire everywhere in
the universe, and so her unity seems multiple; she appears
anywhere in the universe that she pleases, under the various forms
suitable to her parts, and she reveals herself, at will, under some
visible form.

THE HIGHER LOVE IS DEITY, THE LOWER IS A

GUARDIAN.
We shall have to assume also a multiplicity of Venuses, which,
born with Love, occupy the rank of guardians. They originate from
the universal Venus, from which derive all the individual "venuses,"
with the loves peculiar to each. In fact, the soul is the mother of
love; now Venus is the Soul, and Love is the Soul's activity in
desiring the Good. The love which leads each soul to the nature of
the Good, and which belongs to her most exalted part, must also be
considered a deity, inasmuch as it unites the soul to the Good. The
love which belongs to the soul mingled (with matter), is to be
considered a Guardian only.

IT IS AN ERROR TO CONSIDER THE LOVE AS

IDENTICAL WITH THE WORLD.
5. What is the nature of this Guardian, and what is, in general,
the nature of guardians, according to (Plato's treatment of the
subject in) his "Banquet"? What is the nature of guardians? What is
the nature of the Love born of Need (Penia) and Abundance (Poros),
son of Prudence (Metis), at the birth of Venus?132
(Plutarch)133 held that Plato, by Love, meant the world. He
should have stated that Love is part of the world, and was born in it.
His opinion is erroneous, as may be demonstrated by several proofs.
First, (Plato) calls the world a blessed deity, that is self-sufficient;
however, he never attributes these characteristics to Love, which he
always calls a needy being. Further, the world is composed of a body
and a Soul, the latter being Venus; consequently, Venus would be
the directing part of Love; or, if we take the world to mean the
world-Soul, just as we often say "man" when we mean the human
soul,134 Love would be identical with Venus. Third, if Love, which is a
Guardian, is the world, why should not the other Guardians (who
evidently are of the same nature) not also be the world? In this
case, the world would be composed of Guardians. Fourth, how could
we apply to the world that which (Plato) says of Love, that it is the
"guardian of fair children"? Last, Plato describes Love as lacking
clothing, shoes, and lodging. This could not be applied to the world
without absurdity or ridicule.

ALL GUARDIANS ARE BORN OF NEED AND

ABUNDANCE.
 6. To explain the nature and birth of Love, we shall have to
expound the significance of his mother Need to his father
Abundance, and to show how such parents suit him. We shall also
have to show how such parents suit the other Guardians, for all
Guardians, by virtue of their being Guardians, must have the same
nature, unless, indeed, Guardians have only that name in common.

DIFFERENCE BETWEEN DEITIES AND GUARDIANS.

First, we shall have to consider the difference between deities
and guardians. Although it be common to call Guardians deities, we
are here using the word in that sense it bears when one says that
Guardians and deities belong to different species. The deities are
impassible, while the Guardians, though eternal, can experience
passions; placed beneath the deities, but next to us, they occupy the
middle place between deities and men.135

A GUARDIAN IS THE VESTIGE OF A SOUL

DESCENDED INTO THE WORLD.
But how did the Guardians not remain impassible? How did they
descend to an inferior nature? This surely is a question deserving
consideration. We should also inquire whether there be any Guardian
in the intelligible world, whether there be Guardians only here
below, and if deities exist only in the intelligible world. (We shall
answer as follows.) There are deities also here below; and the world
is, as we habitually say, a deity of the third rank, inasmuch as every
supra-lunar being is a divinity. Next, it would be better not to call
any being belonging to the intelligible world a Guardian; and if we
locate the chief Guardian (the Guardian himself) in the intelligible
world, we had better consider him a deity. In the world of sense, all
the visible supra-lunar deities should be called second-rank deities,
in that they are placed below the intelligible deities, and depend on
them as the rays of light from the star from which they radiate. Last,
a Guardian should be defined as the vestige of a soul that had
descended into the world. The latter condition is necessary because
every pure soul begets a deity, and we have already said136 that the
love of such a soul is a deity.

WHY ALL GUARDIANS ARE NOT LOVES.

But why are not all the Guardians Loves? Further, why are they
not completely pure from all matter? Among Guardians, those are
Loves, which owe their existence to a soul's desire for the good and
the beautiful; therefore, all souls that have entered into this world
each generate a Love of this kind. As to the other Guardians, which
are not born of human souls, they are engendered by the different
powers of the universal Soul, for the utility of the All; they complete
and administer all things for the general good. The universal Soul, in
fact, was bound to meet the needs of the universe by begetting
Guardian powers which would suit the All of which she is the soul.

WHY THE GUARDIANS ARE NOT FREE FROM

MATTER.
How do Guardians participate in matter, and of what matter are
they formed? This their matter is not corporeal, otherwise they
would be animals with sensation. In fact, whether they have aerial
or fire-like bodies,137 they must have had a nature primitively
different (from pure Intelligence) to have ultimately united each with
his own body, for that which is entirely pure could not have
immediately united with a body, although many philosophers think
that the being of every Guardian, as guardian, is united to an air-like
or fire-like body. But why is the being of every Guardian mingled
with a body, while the being of every deity is pure, unless in the first
case there be a cause which produces the mingling (with matter)?
This cause must be the existence of an intelligible matter,138 so that
whatever participates in it might, by its means, come to unite with
sense-matter.

SOUL IS A MIXTURE OF REASON AND

INDETERMINATION.
7. Plato's account of the birth of Love132 is that Abundance
intoxicated himself with nectar, this happening before the day of
wine, which implies that Love was born before the sense-world's
existence. Then Need, the mother of Love, must have participated in
the intelligible nature itself, and not in a simple image of the
intelligible nature; she, therefore, approached (the intelligible
nature) and found herself to be a mixture of form and
indeterminateness (or, intelligible matter).139 The soul, in fact,
containing a certain indeterminateness before she had reached the
Good, but feeling a premonition of her existence, formed for herself
a confused and indeterminate image, which became the very
hypostasis (or, form of existence) of Love. Thus, as here, reason
mingles with the unreasonable, with an indeterminate desire, with
an indistinct (faint or obscure) hypostatic (form of existence). What
was born was neither perfect nor complete; it was something needy,
because it was born from an indeterminate desire, and a complete
reason. As to (Love, which is) the thus begotten reason, it is not
pure, since it contains a desire that is indeterminate, unreasonable,
indefinite; nor will it ever be satisfied so long as it contains the
nature of indetermination. It depends on the soul, which is its
generating principle; it is a mixture effected by a reason which,
instead of remaining within itself, is mingled with indetermination.
Besides, it is not Reason itself, but its emanation which mingles with
indetermination.

LOVE IS A GADFLY.
 Love, therefore, is similar to a gad-fly;140 needy by nature, it still
remains needy, whatever it may obtain; it could never be satisfied,
for this would be impossible for a being that is a mixture; no being
could ever be fully satisfied if by its nature it be incapable of
attaining fulness; even were it satisfied for a moment, it could not
retain anything if its nature made it continue to desire.
Consequently, on one side, Love is deprived of all resources141
because of its neediness; and on the other, it possesses the faculty
of acquisition, because of the reason that enters into its constitution.

GUARDIANS, AS WELL AS MEN, ARE URGED BY

DIVINE DISCONTENT.
All other Guardians have a similar constitution. Each of them
desires, and causes the acquisition of the good he is destined to
procure; that is the characteristic they have in common with Love.
Neither could they ever attain satisfaction; they still desire some
particular good. The result of this is that the men who here below
are good are inspired by the love of the true, absolute Good, and not
by the love of such and such a particular good.142 Those who are
subordinated to divers Guardians are successively subordinated to
such or such a Guardian; they let the simple and pure love of the
absolute Good rest within themselves, while they see to it that their
actions are presided over by another Guardian, that is, another
power of their soul, which is immediately superior to that which
directs them, or is active within them.143 As to the men who, driven
by evil impulses, desire evil things, they seem to have chained down
all the loves in their souls, just as, by false opinions, they darken the
right reason which is innate within them. Thus all the loves
implanted in us by nature, and which conform to nature, are all
good; those that belong to the inferior part of the soul are inferior in
rank and power; those that belong to the superior part are superior;
all belong to the being of the soul. As to the loves which are
contrary to nature, they are the passions of strayed souls, having
nothing essential or substantial; for they are not engendered by the
pure Soul; they are the fruits of the faults of the soul which
produces them according to her vicious habits and dispositions.

RIGHT THOUGHTS POSSESS REAL EXISTENCE.

In general, we might admit that the true goods which are
possessed by the soul when she acts conformably to her nature, by
applying herself to things determined (by reason), constitute real
being; that the others, on the contrary, are not engendered by the
very action of the soul, and are only passions.144 Likewise, false
intellections lack real being, such as belongs to true intellections,
which are eternal and determinate, possessing simultaneously the
intellectual act, the intelligible existence and essence; and this latter
not only in general, but in each real intelligible being (manifesting?)
Intelligence in each idea. As to us, we must acknowledge that we
possess only intellection and the intelligible; we do not possess them
together (or completely), but only in general; and hence comes our
love for generalities. Our conceptions, indeed, usually trend towards
the general. It is only by accident that we conceive something
particular; when, for instance, we conceive that some particular
triangle's angles amount to two right angles, it is only as a result of
first having conceived that the triangle in general possesses this
property.

JUPITER, THE GREAT CHIEF, OR THIRD GOD, IS THE

SOUL, OR VENUS.
8. Finally, who is this Jupiter into whose gardens (Plato said
that) Abundance entered? What are these gardens? As we have
already agreed, Venus is the Soul, and Abundance is the Reason of
all things. We still have to explain the significance of Jupiter and his
gardens.
 Jupiter cannot well signify anything else than the soul, since we
have already admitted that the soul was Venus. We must here
consider Jupiter as that deity which Plato, in his Phaedrus, calls the
Great Chief;145 and, elsewhere, as I think, the Third God. He
explains himself more clearly in this respect in the Philebus,146
where he says that Jupiter "has a royal soul, a royal intelligence."
Since Jupiter is, therefore, both an intelligence and a soul, since he
forms part of the order of causes, since we must assign him his rank
according to what is best in him; and for several reasons, chiefly
because he is a cause, a royal and directing cause, he must be
considered as the Intelligence. Venus (that is, Aphrodite) which
belongs to him, which proceeds from him, and accompanies him,
occupies the rank of a soul, for she represents in the soul that which
is beautiful, brilliant, pure, and delicate ("abron"); and that is why
she is called "Aphrodite."147 In fact, if we refer the male deities to
the intellect, and if we consider the female deities as souls—because
a soul is attached to each intelligence—we shall have one more
reason to relate Venus to Jupiter. Our views upon this point are
confirmed by the teachings of the priests and the (Orphic)
Theologians, who always identify Venus and Juno, and who call the
evening star, or Star of Venus, the Star of Juno.148

JUPITER'S GARDEN IS THE FRUITFUL REASON THAT

BEGETS EVERY OBJECT.
9. Abundance, being the reason of the things that exist in
Intelligence and in the intelligible world—I mean the reason which
pours itself out and develops—trends towards the soul, and exists
therein. Indeed, the (Being) which remains united in Intelligence
does not emanate from a foreign principle, while the intoxication of
Abundance is only a factitious fulness. But what is that which is
intoxicated with nectar? It is Reason that descends from the superior
principle to the inferior; the Soul receives it from Intelligence at the
moment of the birth of Venus; that is why it is said that the nectar
flows in the garden of Jupiter. This whole garden is the glory and
splendor of the wealth (of Intelligence);149 this glory originates in
the reason of Jupiter; this splendor is the light which the intelligence
of this Deity sheds on the soul. What else but the beauties and
splendors of this deity could the "gardens of Jupiter" signify? On the
other hand, what else can the beauties and splendors of Jupiter be,
if not the reasons150 that emanate from him? At the same time,
these reasons are called Abundance (Poros, or "euporia"), the
wealth of the beauties which manifest; that is the nectar which
intoxicates Abundance.151 For indeed what else is the nectar among
the deities, but that which each of them receives? Now Reason is
that which is received from Intelligence by its next inferior principle.
Intelligence possesses itself fully; yet this self-possession does not
intoxicate it, as it possesses nothing foreign thereto. On the contrary,
Reason is engendered by Intelligence. As it exists beneath
Intelligence, and does not, as Intelligence does, belong to itself, it
exists in another principle; consequently, we say that Abundance is
lying down in the garden of Jupiter, and that at the very moment
when Venus, being born, takes her place among living beings.

THE OBJECT OF MYTHS IS TO ANALYSE; AND TO

DISTINGUISH.
10. If myths are to earn their name (of something "reserved," or
"silent") they must necessarily develop their stories under the
category of time, and present as separate many things, that are
simultaneous, though different in rank or power. That is the reason
they so often mention the generation of ungenerated things, and
that they so often separate simultaneous things.152 But after having
thus (by this analysis) yielded us all the instruction possible to them,
these myths leave it to the reader to make a synthesis thereof. Ours
is the following:
 SIGNIFICANCE OF THE PLATONIC MYTH OF THE
GARDEN OF JUPITER.
Venus is the Soul which coexists with Intelligence, and subsists
by Intelligence. She receives from Intelligence the reasons150 which
fill her,153 and embellishes her, and whose abundance makes us see
in the Soul the splendor and image of all beauties. The reasons
which subsist in the Soul are Abundance154 of the nectar which flows
down from above. Their splendors which shine in the Soul, as in life,
represent the Garden of Jupiter. Abundance falls asleep in this
garden, because he is weighted down by the fulness contained
within him. As life manifests and ever exists in the order of beings,
(Plato) says that the deities are seated at a feast, because they ever
enjoy this beatitude.

SIGNIFICANCE OF THE PLATONIC MYTH OF THE

BIRTH OF LOVE.
Since the Soul herself exists, Love also must necessarily exist,
and it owes its existence to the desire of the Soul which aspires to
the better and the Good. Love is a mixed being: it participates in
need, because it needs satisfaction; it also participates in
abundance, because it struggles to acquire good which it yet lacks,
inasmuch as only that which lacked good entirely would cease to
seek it. It is, therefore, correct to call Love the son of Abundance
and Need, which are constituted by lack, desire, and reminiscence of
the reasons—or ideas—which, reunited in the soul, have therein
engendered that aspiration towards the good which constitutes love.
Its mother is Need, because desire belongs only to need, and "need"
signifies matter, which is entire need.155 Even indetermination, which
characterizes the desire of the good, makes the being which desires
the Good play the part of matter—since such a being would have
neither form nor reason, considered only from its desiring. It is a
form only inasmuch as it remains within itself. As soon as it desires
to attain a new perfection, it is matter relatively to the being from
whom it desires to receive somewhat.

LOVE IS BOTH MATERIAL AND A GUARDIAN.

That is why Love is both a being which participates in matter,
and is also a Guardian born of the soul; it is the former, inasmuch as
it does not completely possess the good; it is the latter, inasmuch as
it desires the Good from the very moment of its birth.
 FIRST ENNEAD, BOOK EIGHT.
Of the Nature and Origin of Evils.156

QUESTIONS TO BE DISCUSSED.
1. Studying the origin of evils that might affect all beings in
general, or some one class in particular, it is reasonable to begin by
defining evil, from a consideration of its nature. That would be the
best way to discover whence it arises, where it resides, to whom it
may happen, and in general to decide if it be something real. Which
one of our faculties then can inform us of the nature of evil? This
question is not easy to solve, because there must be an analogy
between the knower and the known.157 The Intelligence and the
Soul may indeed cognize forms and fix their desires on them,
because they themselves are forms; but evil, which consists in the
absence of all goods, could not be described as a form.158 But
inasmuch as there can be but one single science, to embrace even
contraries, and as the evil is the contrary of the good, knowledge of
the good implies that of evil. Therefore, to determine the nature of
evil, we shall first have to determine that of good, for the higher
things must precede the lower, as some are forms and others are
not, being rather a privation of the good. Just in what sense evil is
the contrary of the good must also be determined; as for instance, if
the One be the first, and matter the last;159 or whether the One be
form, and matter be its absence. Of this further.160

A. PRIMARY AND SECONDARY EVIL.

 A DEFINITION OF EVIL BY CONTRAST WITH THE
GOOD.
2. Let us now determine the nature of the Good, at least so far
as is demanded by the present discussion. The Good is the principle
on which all depends, to which everything aspires, from which
everything issues, and of which everything has need. As to Him, He
suffices to himself, being complete, so He stands in need of nothing;
He is the measure161 and the end of all things; and from Him spring
intelligence, being, soul, life, and intellectual contemplation.

NATURE OF DIVINE INTELLIGENCE.

All these beautiful things exist as far as He does; but He is the
one Principle that possesses supreme beauty, a principle that is
superior to the things that are best. He reigns royally,162 in the
intelligible world, being Intelligence itself, very differently from what
we call human intelligences. The latter indeed are all occupied with
propositions, discussions about the meanings of words, reasonings,
examinations of the validity of conclusions, observing the
concatenation of causes, being incapable of possessing truth "a
priori," and though they be intelligences, being devoid of all ideas
before having been instructed by experience; though they,
nevertheless, were intelligences. Such is not the primary
Intelligence. On the contrary, it possesses all things. Though
remaining within itself, it is all things; it possesses all things, without
possessing them (in the usual acceptation of that term); the things
that subsist in it not differing from it, and not being separated from
each other. Each one of them is all the others,163 is everything and
everywhere, although not confounded with other things, and
remaining distinct therefrom.

NATURE OF THE UNIVERSAL SOUL.

 The power which participates in Intelligence (the universal Soul)
does not participate in it in a manner such as to be equal to it, but
only in the measure of her ability to participate therein. She is the
first actualization of Intelligence, the first being that Intelligence,
though remaining within itself, begets. She directs her whole activity
towards supreme Intelligence, and lives exclusively thereby. Moving
from outside Intelligence, and around it, according to the laws of
harmony,164 the universal Soul fixes her glance upon it. By
contemplation penetrating into its inmost depths, through
Intelligence she sees the divinity Himself. Such is the nature of the
serene and blissful existence of the divinities, a life where evil has no
place.

EVIL EXISTS AS A CONSEQUENCE OF THE

DERIVATIVE GOODS OF THE THIRD RANK.
If everything stopped there (and if there were nothing beyond
the three principles here described), evil would not exist (and there
would be nothing but goods). But there are goods of the first,
second and third ranks. Though all relate to the King of all things,165
who is their author, and from whom they derive their goodness, yet
the goods of the second rank relate more specially to the second
principle; and to the third principle, the goods of the third rank.

NATURE OF EVIL.
3. As these are real beings, and as the first Principle is their
superior, evil could not exist in such beings, and still less in Him, who
is superior to them; for all these things are good. Evil then must be
located in non-being, and must, so to speak, be its form, referring to
the things that mingle with it, or have some community with it. This
"non-being," however, is not absolute non-being.166 Its difference
from being resembles the difference between being and movement
or rest; but only as its image, or something still more distant from
reality. Within this non-being are comprised all sense-objects, and all
their passive modifications; or, evil may be something still more
inferior, like their accident or principle, or one of the things that
contribute to its constitution. To gain some conception of evil it may
be represented by the contrast between measure and
incommensurability; between indetermination and its goal; between
lack of form and the creating principle of form; between lack and
self-sufficiency; as the perpetual unlimited and changeableness; as
passivity, insatiableness, and absolute poverty.167 Those are not the
mere accidents of evil, but its very essence; all of that can be
discovered when any part of evil is examined. The other objects,
when they participate in the evil and resemble it, become evil
without however being absolute Evil.

EVIL POSSESSES A LOWER FORM OF BEING.

All these things participate in a being; they do not differ from it,
they are identical with it, and constitute it. For if evil be an accident
in something, then evil, though not being a real being, must be
something by itself. Just as, for the good, there is the Good in itself,
and the good considered as an attribute of a foreign subject,
likewise, for evil, one may distinguish Evil in itself, and evil as
accident.

EVIL AS INFINITE AND FORMLESSNESS IN ITSELF.

It might be objected that it is impossible to conceive of
indetermination outside of the indeterminate, any more than
determination outside of the determinate; or measure outside of the
measured. (We shall have to answer that) just as determination
does not reside in the determined (or measure in the measured), so
indetermination cannot exist within the indeterminate. If it can exist
in something other than itself, it will be either in the indeterminate,
or in the determinate. If in the indeterminate, it is evident that it
Welcome to our website – the perfect destination for book lovers and
knowledge seekers. We believe that every book holds a new world,
offering opportunities for learning, discovery, and personal growth.
That’s why we are dedicated to bringing you a diverse collection of
books, ranging from classic literature and specialized publications to
self-development guides and children's books.

More than just a book-buying platform, we strive to be a bridge

connecting you with timeless cultural and intellectual values. With an
elegant, user-friendly interface and a smart search system, you can
quickly find the books that best suit your interests. Additionally,
our special promotions and home delivery services help you save time
and fully enjoy the joy of reading.

Join us on a journey of knowledge exploration, passion nurturing, and

personal growth every day!

ebookbell.com