The Swift Programming Language Swift 57 Apple

Inc download

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

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 57 Apple Inc

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

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

Mastering Swift 53 Upgrade Your Knowledge And Become An Expert In The

Latest Version Of The Swift Programming Language 6th Edition Jon
Hoffman

https://ebookbell.com/product/mastering-swift-53-upgrade-your-
knowledge-and-become-an-expert-in-the-latest-version-of-the-swift-
programming-language-6th-edition-jon-hoffman-22069006
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 Swift 4 Apple Inc

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

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 Prerelease Apple Inc

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

PDF conversion courtesy of www.appsdissected.com

About Swift

Swift is a fantastic way to write software, whether it’s for phones,

desktops, servers, or anything else that runs code. It’s a safe, fast,
and interactive programming language that combines the best in
modern language thinking with wisdom from the wider Apple
engineering culture and the diverse contributions from its open-
source community. The compiler is optimized for performance and
the language is optimized for development, without compromising on
either.

Swift is friendly to new programmers. It’s an industrial-quality

programming language that’s as expressive and enjoyable as a
scripting language. Writing Swift code in a playground lets you
experiment with code and see the results immediately, without the
overhead of building and running an app.

Swift defines away large classes of common programming errors by

adopting modern programming patterns:

Variables are always initialized before use.

Array indices are checked for out-of-bounds errors.

Integers are checked for overflow.

Optionals ensure that nil values are handled explicitly.

Memory is managed automatically.

Error handling allows controlled recovery from unexpected

failures.

Swift code is compiled and optimized to get the most out of modern
hardware. The syntax and standard library have been designed
based on the guiding principle that the obvious way to write your code

PDF conversion courtesy of www.appsdissected.com

should also perform the best. Its combination of safety and speed
make Swift an excellent choice for everything from “Hello, world!” to
an entire operating system.

Swift combines powerful type inference and pattern matching with a

modern, lightweight syntax, allowing complex ideas to be expressed
in a clear and concise manner. As a result, code is not just easier to
write, but easier to read and maintain as well.

Swift has been years in the making, and it continues to evolve with
new features and capabilities. Our goals for Swift are ambitious. We
can’t wait to see what you create with it.

PDF conversion courtesy of www.appsdissected.com

Version Compatibility

This book describes Swift 5.7, the default version of Swift that’s
included in Xcode 14. You can use Xcode 14 to build targets that are
written in either Swift 5.7, Swift 4.2, or Swift 4.

When you use Xcode 14 to build Swift 4 and Swift 4.2 code, most
Swift 5.7 functionality is available. That said, the following changes
are available only to code that uses Swift 5.7 or later:

Functions that return an opaque type require the Swift 5.1

runtime.

The try? expression doesn’t introduce an extra level of

optionality to expressions that already return optionals.

Large integer literal initialization expressions are inferred to be of

the correct integer type. For example,
UInt64(0xffff_ffff_ffff_ffff) evaluates to the correct value
rather than overflowing.

Concurrency requires Swift 5.7 or later, and a version of the Swift

standard library that provides the corresponding concurrency types.
On Apple platforms, set a deployment target of at least iOS 15,
macOS 12, tvOS 15, or watchOS 8.0.

A target written in Swift 5.7 can depend on a target that’s written in

Swift 4.2 or Swift 4, and vice versa. This means, if you have a large
project that’s divided into multiple frameworks, you can migrate your
code from Swift 4 to Swift 5.7 one framework at a time.

PDF conversion courtesy of www.appsdissected.com

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:

1 print("Hello, world!")
2 // Prints "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.

NOTE

On a Mac with Xcode installed, or on an iPad with Swift Playgrounds, you can
open this chapter as a playground. Playgrounds allow you to edit the code
listings and see the result immediately.
Download Playground

Simple Values

PDF conversion courtesy of www.appsdissected.com

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.

1 var myVariable = 42
2 myVariable = 50
3 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 an
integer.

If the initial value doesn’t provide enough information (or if there isn’t
an initial value), specify the type by writing it after the variable,
separated by a colon.

1 let implicitInteger = 70
2 let implicitDouble = 70.0
3 let explicitDouble: Double = 70

EXPERIMENT

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.

PDF conversion courtesy of www.appsdissected.com

 1 let label = "The width is "
2 let width = 94
3 let widthLabel = label + String(width)

EXPERIMENT

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:

1 let apples = 3
2 let oranges = 5
3 let appleSummary = "I have \(apples) apples."
4 let fruitSummary = "I have \(apples + oranges)
pieces of fruit."

EXPERIMENT

Use \() to include a floating-point calculation in a string and to include

someone’s name in a greeting.

Use three double quotation marks (""") for strings that take up
multiple lines. Indentation at the start of each quoted line is removed,
as long as it matches the indentation of the closing quotation marks.
For example:

PDF conversion courtesy of www.appsdissected.com

 1 let quotation = """
2 I said "I have \(apples) apples."
3 And then I said "I have \(apples + oranges) pieces
of fruit."
4 """

Create arrays and dictionaries using brackets ([]), and access their
elements by writing the index or key in brackets. A comma is allowed
after the last element.

1 var fruits = ["strawberries", "limes", "tangerines"]

2 fruits[1] = "grapes"
3
4 var occupations = [
5 "Malcolm": "Captain",
6 "Kaylee": "Mechanic",
7 ]
8 occupations["Jayne"] = "Public Relations"

Arrays automatically grow as you add elements.

1 fruits.append("blueberries")
2 print(fruits)

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

1 let emptyArray: [String] = []

2 let emptyDictionary: [String: Float] = [:]

PDF conversion courtesy of www.appsdissected.com

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.

1 fruits = []
2 occupations = [:]

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

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

2 var teamScore = 0
3 for score in individualScores {
4 if score > 50 {
5 teamScore += 3
6 } else {
7 teamScore += 1
8 }
9 }
10 print(teamScore)
11 // Prints "11"

In an if statement, the conditional must be a Boolean expression—

this means that code such as if score { ... } is an error, not an

PDF conversion courtesy of www.appsdissected.com

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 a value
is missing. Write a question mark (?) after the type of a value to mark
the value as optional.

1 var optionalString: String? = "Hello"

2 print(optionalString == nil)
3 // Prints "false"
4
5 var optionalName: String? = "John Appleseed"
6 var greeting = "Hello!"
7 if let name = optionalName {
8 greeting = "Hello, \(name)"
9 }

EXPERIMENT

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.

Another way to handle optional values is to provide a default value

using the ?? operator. If the optional value is missing, the default
value is used instead.

PDF conversion courtesy of www.appsdissected.com

 1 let nickname: String? = nil
2 let fullName: String = "John Appleseed"
3 let informalGreeting = "Hi \(nickname ?? fullName)"

You can use a shorter spelling to unwrap a value, using the same
name for that unwrapped value.

1 if let nickname {
2 print("Hey, \(nickname)")
3 }

Switches support any kind of data and a wide variety of comparison

operations—they aren’t limited to integers and tests for equality.

1 let vegetable = "red pepper"

2 switch vegetable {
3 case "celery":
4 print("Add some raisins and make ants on a
log.")
5 case "cucumber", "watercress":
6 print("That would make a good tea sandwich.")
7 case let x where x.hasSuffix("pepper"):
8 print("Is it a spicy \(x)?")
9 default:
10 print("Everything tastes good in soup.")
11 }
12 // Prints "Is it a spicy red pepper?"

PDF conversion courtesy of www.appsdissected.com

 EXPERIMENT

Try removing the default case. What error do you get?

Notice how let can be used in a pattern to assign the value that
matched the pattern to a constant.

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 you don’t 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. Dictionaries are an
unordered collection, so their keys and values are iterated over in an
arbitrary order.

PDF conversion courtesy of www.appsdissected.com

 1 let interestingNumbers = [
2 "Prime": [2, 3, 5, 7, 11, 13],
3 "Fibonacci": [1, 1, 2, 3, 5, 8],
4 "Square": [1, 4, 9, 16, 25],
5 ]
6 var largest = 0
7 for (_, numbers) in interestingNumbers {
8 for number in numbers {
9 if number > largest {
10 largest = number
11 }
12 }
13 }
14 print(largest)
15 // Prints "25"

EXPERIMENT

Replace the _ with a variable name, and keep track of which kind of number
was the largest.

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.

PDF conversion courtesy of www.appsdissected.com

 1 var n = 2
2 while n < 100 {
3 n *= 2
4 }
5 print(n)
6 // Prints "128"
7
8 var m = 2
9 repeat {
10 m *= 2
11 } while m < 100
12 print(m)
13 // Prints "128"

You can keep an index in a loop by using ..< to make a range of

indexes.

1 var total = 0
2 for i in 0..<4 {
3 total += i
4 }
5 print(total)
6 // Prints "6"

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

PDF conversion courtesy of www.appsdissected.com

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.

1 func greet(person: String, day: String) -> String {

2 return "Hello \(person), today is \(day)."
3 }
4 greet(person: "Bob", day: "Tuesday")

EXPERIMENT

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

By default, functions use their parameter names as labels for their

arguments. Write a custom argument label before the parameter
name, or write _ to use no argument label.

1 func greet(_ person: String, on day: String) ->

String {
2 return "Hello \(person), today is \(day)."
3 }
4 greet("John", on: "Wednesday")

Use a tuple to make a compound value—for example, to return

multiple values from a function. The elements of a tuple can be
referred to either by name or by number.

PDF conversion courtesy of www.appsdissected.com

 1 func calculateStatistics(scores: [Int]) -> (min:
Int, max: Int, sum: Int) {
2 var min = scores[0]
3 var max = scores[0]
4 var sum = 0
5
6 for score in scores {
7 if score > max {
8 max = score
9 } else if score < min {
10 min = score
11 }
12 sum += score
13 }
14
15 return (min, max, sum)
16 }
17 let statistics = calculateStatistics(scores: [5, 3,
100, 3, 9])
18 print(statistics.sum)
19 // Prints "120"
20 print(statistics.2)
21 // Prints "120"

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’s long or complex.

PDF conversion courtesy of www.appsdissected.com

 1 func returnFifteen() -> Int {
2 var y = 10
3 func add() {
4 y += 5
5 }
6 add()
7 return y
8 }
9 returnFifteen()

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

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

2 func addOne(number: Int) -> Int {
3 return 1 + number
4 }
5 return addOne
6 }
7 var increment = makeIncrementer()
8 increment(7)

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

PDF conversion courtesy of www.appsdissected.com

 1 func hasAnyMatches(list: [Int], condition: (Int) ->
Bool) -> Bool {
2 for item in list {
3 if condition(item) {
4 return true
5 }
6 }
7 return false
8 }
9 func lessThanTen(number: Int) -> Bool {
10 return number < 10
11 }
12 var numbers = [20, 19, 7, 12]
13 hasAnyMatches(list: numbers, condition: lessThanTen)

Functions are actually a special case of closures: blocks of code that

can be called later. The code in a closure has access to things like
variables and functions that were available in the scope where the
closure was created, even if the closure is in a different scope when
it’s executed—you saw an example of this already with nested
functions. 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.

1 numbers.map({ (number: Int) -> Int in

2 let result = 3 * number
3 return result
4 })

PDF conversion courtesy of www.appsdissected.com

 EXPERIMENT

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.

1 let mappedNumbers = numbers.map({ number in 3 *

number })
2 print(mappedNumbers)
3 // Prints "[60, 57, 21, 36]"

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. When a closure is the only argument to a function, you
can omit the parentheses entirely.

1 let sortedNumbers = numbers.sorted { $0 > $1 }

2 print(sortedNumbers)
3 // Prints "[20, 19, 12, 7]"

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’s in the context of a class.
Likewise, method and function declarations are written the same way.

PDF conversion courtesy of www.appsdissected.com

 1 class Shape {
2 var numberOfSides = 0
3 func simpleDescription() -> String {
4 return "A shape with \(numberOfSides)
sides."
5 }
6 }

EXPERIMENT

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.

1 var shape = Shape()

2 shape.numberOfSides = 7
3 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.

PDF conversion courtesy of www.appsdissected.com

 1 class NamedShape {
2 var numberOfSides: Int = 0
3 var name: String
4
5 init(name: String) {
6 self.name = name
7 }
8
9 func simpleDescription() -> String {
10 return "A shape with \(numberOfSides)
sides."
11 }
12 }

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’s 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

PDF conversion courtesy of www.appsdissected.com

detects methods with override that don’t actually override any
method in the superclass.

1 class Square: NamedShape {

2 var sideLength: Double
3
4 init(sideLength: Double, name: String) {
5 self.sideLength = sideLength
6 super.init(name: name)
7 numberOfSides = 4
8 }
9
10 func area() -> Double {
11 return sideLength * sideLength
12 }
13
14 override func simpleDescription() -> String {
15 return "A square with sides of length \
(sideLength)."
16 }
17 }
18 let test = Square(sideLength: 5.2, name: "my test
square")
19 test.area()
20 test.simpleDescription()

PDF conversion courtesy of www.appsdissected.com

 EXPERIMENT

Make another subclass of NamedShape called Circle that takes a radius and
a name as arguments to its initializer. Implement an area() and a
simpleDescription() method on the Circle class.

In addition to simple properties that are stored, properties can have a

getter and a setter.

PDF conversion courtesy of www.appsdissected.com

1 class EquilateralTriangle: NamedShape {
2 var sideLength: Double = 0.0
3
4 init(sideLength: Double, name: String) {
5 self.sideLength = sideLength
6 super.init(name: name)
7 numberOfSides = 3
8 }
9
10 var perimeter: Double {
11 get {
12 return 3.0 * sideLength
13 }
14 set {
15 sideLength = newValue / 3.0
16 }
17 }
18
19 override func simpleDescription() -> String {
20 return "An equilateral triangle with sides
of length \(sideLength)."
21 }
22 }
23 var triangle = EquilateralTriangle(sideLength: 3.1,
name: "a triangle")
24 print(triangle.perimeter)

PDF conversion courtesy of www.appsdissected.com

 25 // Prints "9.3"
26 triangle.perimeter = 9.9
27 print(triangle.sideLength)
28 // Prints "3.3000000000000003"

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’s run before and after setting a new value, use willSet and
didSet. The code you provide is run any time the value changes
outside of an initializer. For example, the class below ensures that the
side length of its triangle is always the same as the side length of its
square.

PDF conversion courtesy of www.appsdissected.com

1 class TriangleAndSquare {
2 var triangle: EquilateralTriangle {
3 willSet {
4 square.sideLength = newValue.sideLength
5 }
6 }
7 var square: Square {
8 willSet {
9 triangle.sideLength =
newValue.sideLength
10 }
11 }
12 init(size: Double, name: String) {
13 square = Square(sideLength: size, name:
name)
14 triangle = EquilateralTriangle(sideLength:
size, name: name)
15 }
16 }
17 var triangleAndSquare = TriangleAndSquare(size: 10,
name: "another test shape")
18 print(triangleAndSquare.square.sideLength)
19 // Prints "10.0"
20 print(triangleAndSquare.triangle.sideLength)
21 // Prints "10.0"

PDF conversion courtesy of www.appsdissected.com

 22 triangleAndSquare.square = Square(sideLength: 50,
name: "larger square")
23 print(triangleAndSquare.triangle.sideLength)
24 // Prints "50.0"

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.

1 let optionalSquare: Square? = Square(sideLength:

2.5, name: "optional square")
2 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.

PDF conversion courtesy of www.appsdissected.com

1 enum Rank: Int {
2 case ace = 1
3 case two, three, four, five, six, seven, eight,
nine, ten
4 case jack, queen, king
5
6 func simpleDescription() -> String {
7 switch self {
8 case .ace:
9 return "ace"
10 case .jack:
11 return "jack"
12 case .queen:
13 return "queen"
14 case .king:
15 return "king"
16 default:
17 return String(self.rawValue)
18 }
19 }
20 }
21 let ace = Rank.ace
22 let aceRawValue = ace.rawValue

PDF conversion courtesy of www.appsdissected.com

 EXPERIMENT

Write a function that compares two Rank values by comparing their raw
values.

By default, Swift assigns the raw values starting at zero and

incrementing by one each time, but you can change this behavior by
explicitly specifying values. In the example above, Ace is explicitly
given a raw value of 1, and 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 rawValue property to access the raw
value of an enumeration case.

Use the init?(rawValue:) initializer to make an instance of an

enumeration from a raw value. It returns either the enumeration case
matching the raw value or nil if there’s no matching Rank.

1 if let convertedRank = Rank(rawValue: 3) {

2 let threeDescription =
convertedRank.simpleDescription()
3 }

The case 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.

PDF conversion courtesy of www.appsdissected.com

 1 enum Suit {
2 case spades, hearts, diamonds, clubs
3
4 func simpleDescription() -> String {
5 switch self {
6 case .spades:
7 return "spades"
8 case .hearts:
9 return "hearts"
10 case .diamonds:
11 return "diamonds"
12 case .clubs:
13 return "clubs"
14 }
15 }
16 }
17 let hearts = Suit.hearts
18 let heartsDescription = hearts.simpleDescription()

EXPERIMENT

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 case of the enumeration is
referred to above: When assigning a value to the hearts constant, the
enumeration case Suit.hearts is referred to by its full name because
the constant doesn’t have an explicit type specified. Inside the switch,
the enumeration case is referred to by the abbreviated form .hearts

PDF conversion courtesy of www.appsdissected.com

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.

If an enumeration has raw values, those values are determined as

part of the declaration, which means every instance of a particular
enumeration case always has the same raw value. Another choice for
enumeration cases is to have values associated with the case—
these values are determined when you make the instance, and they
can be different for each instance of an enumeration case. You can
think of the associated values as behaving like stored properties of
the enumeration case instance. For example, consider the case of
requesting the sunrise and sunset times from a server. The server
either responds with the requested information, or it responds with a
description of what went wrong.

PDF conversion courtesy of www.appsdissected.com

 1 enum ServerResponse {
2 case result(String, String)
3 case failure(String)
4 }
5
6 let success = ServerResponse.result("6:00 am", "8:09
pm")
7 let failure = ServerResponse.failure("Out of
cheese.")
8
9 switch success {
10 case let .result(sunrise, sunset):
11 print("Sunrise is at \(sunrise) and sunset is at
\(sunset).")
12 case let .failure(message):
13 print("Failure... \(message)")
14 }
15 // Prints "Sunrise is at 6:00 am and sunset is at
8:09 pm."

EXPERIMENT

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.

PDF conversion courtesy of www.appsdissected.com

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’re passed around in your
code, but classes are passed by reference.

1 struct Card {
2 var rank: Rank
3 var suit: Suit
4 func simpleDescription() -> String {
5 return "The \(rank.simpleDescription()) of \
(suit.simpleDescription())"
6 }
7 }
8 let threeOfSpades = Card(rank: .three, suit:
.spades)
9 let threeOfSpadesDescription =
threeOfSpades.simpleDescription()

EXPERIMENT

Write a function that returns an array containing a full deck of cards, with one
card of each combination of rank and suit.

Concurrency
Use async to mark a function that runs asynchronously.

PDF conversion courtesy of www.appsdissected.com

 1 func fetchUserID(from server: String) async -> Int {
2 if server == "primary" {
3 return 97
4 }
5 return 501
6 }

You mark a call to an asynchronous function by writing await in front

of it.

1 func fetchUsername(from server: String) async ->

String {
2 let userID = await fetchUserID(from: server)
3 if userID == 501 {
4 return "John Appleseed"
5 }
6 return "Guest"
7 }

Use async let to call an asynchronous function, letting it run in

parallel with other asynchronous code. When you use the value it
returns, write await.

PDF conversion courtesy of www.appsdissected.com

 1 func connectUser(to server: String) async {
2 async let userID = fetchUserID(from: server)
3 async let username = fetchUsername(from: server)
4 let greeting = await "Hello \(username), user ID
\(userID)"
5 print(greeting)
6 }

Use Task to call asynchronous functions from synchronous code,

without waiting for them to return.

1 Task {
2 await connectUser(to: "primary")
3 }
4 // Prints "Hello Guest, user ID 97"

Protocols and Extensions

Use protocol to declare a protocol.

1 protocol ExampleProtocol {
2 var simpleDescription: String { get }
3 mutating func adjust()
4 }

Classes, enumerations, and structures can all adopt protocols.

PDF conversion courtesy of www.appsdissected.com

1 class SimpleClass: ExampleProtocol {
2 var simpleDescription: String = "A very simple
class."
3 var anotherProperty: Int = 69105
4 func adjust() {
5 simpleDescription += " Now 100% adjusted."
6 }
7 }
8 var a = SimpleClass()
9 a.adjust()
10 let aDescription = a.simpleDescription
11
12 struct SimpleStructure: ExampleProtocol {
13 var simpleDescription: String = "A simple
structure"
14 mutating func adjust() {
15 simpleDescription += " (adjusted)"
16 }
17 }
18 var b = SimpleStructure()
19 b.adjust()
20 let bDescription = b.simpleDescription

EXPERIMENT

Add another requirement to ExampleProtocol. What changes do you need to

make to SimpleClass and SimpleStructure so that they still conform to the
protocol?

PDF conversion courtesy of www.appsdissected.com

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’s declared elsewhere, or even to
a type that you imported from a library or framework.

1 extension Int: ExampleProtocol {

2 var simpleDescription: String {
3 return "The number \(self)"
4 }
5 mutating func adjust() {
6 self += 42
7 }
8 }
9 print(7.simpleDescription)
10 // Prints "The number 7"

EXPERIMENT

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
aren’t available.

PDF conversion courtesy of www.appsdissected.com

 1 let protocolValue: ExampleProtocol = a
2 print(protocolValue.simpleDescription)
3 // Prints "A very simple class. Now 100% adjusted."
4 // print(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.

Error Handling
You represent errors using any type that adopts the Error protocol.

1 enum PrinterError: Error {

2 case outOfPaper
3 case noToner
4 case onFire
5 }

Use throw to throw an error and throws to mark a function that can
throw an error. If you throw an error in a function, the function returns
immediately and the code that called the function handles the error.

PDF conversion courtesy of www.appsdissected.com

 1 func send(job: Int, toPrinter printerName: String)
throws -> String {
2 if printerName == "Never Has Toner" {
3 throw PrinterError.noToner
4 }
5 return "Job sent"
6 }

There are several ways to handle errors. One way is to use do-catch.
Inside the do block, you mark code that can throw an error by writing
try in front of it. Inside the catch block, the error is automatically
given the name error unless you give it a different name.

1 do {
2 let printerResponse = try send(job: 1040,
toPrinter: "Bi Sheng")
3 print(printerResponse)
4 } catch {
5 print(error)
6 }
7 // Prints "Job sent"

EXPERIMENT

Change the printer name to "Never Has Toner", so that the

send(job:toPrinter:) function throws an error.

You can provide multiple catch blocks that handle specific errors. You
write a pattern after catch just as you do after case in a switch.

PDF conversion courtesy of www.appsdissected.com

 1 do {
2 let printerResponse = try send(job: 1440,
toPrinter: "Gutenberg")
3 print(printerResponse)
4 } catch PrinterError.onFire {
5 print("I'll just put this over here, with the
rest of the fire.")
6 } catch let printerError as PrinterError {
7 print("Printer error: \(printerError).")
8 } catch {
9 print(error)
10 }
11 // Prints "Job sent"

EXPERIMENT

Add code to throw an error inside the do block. What kind of error do you need
to throw so that the error is handled by the first catch block? What about the
second and third blocks?

Another way to handle errors is to use try? to convert the result to an

optional. If the function throws an error, the specific error is discarded
and the result is nil. Otherwise, the result is an optional containing
the value that the function returned.

1 let printerSuccess = try? send(job: 1884, toPrinter:

"Mergenthaler")
2 let printerFailure = try? send(job: 1885, toPrinter:
"Never Has Toner")

PDF conversion courtesy of www.appsdissected.com

Use defer to write a block of code that’s executed after all other code
in the function, just before the function returns. The code is executed
regardless of whether the function throws an error. You can use
defer to write setup and cleanup code next to each other, even
though they need to be executed at different times.

1 var fridgeIsOpen = false

2 let fridgeContent = ["milk", "eggs", "leftovers"]
3
4 func fridgeContains(_ food: String) -> Bool {
5 fridgeIsOpen = true
6 defer {
7 fridgeIsOpen = false
8 }
9
10 let result = fridgeContent.contains(food)
11 return result
12 }
13 fridgeContains("banana")
14 print(fridgeIsOpen)
15 // Prints "false"

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

PDF conversion courtesy of www.appsdissected.com

 1 func makeArray<Item>(repeating item: Item,
numberOfTimes: Int) -> [Item] {
2 var result: [Item] = []
3 for _ in 0..<numberOfTimes {
4 result.append(item)
5 }
6 return result
7 }
8 makeArray(repeating: "knock", numberOfTimes: 4)

You can make generic forms of functions and methods, as well as

classes, enumerations, and structures.

1 // Reimplement the Swift standard library's optional

type
2 enum OptionalValue<Wrapped> {
3 case none
4 case some(Wrapped)
5 }
6 var possibleInteger: OptionalValue<Int> = .none
7 possibleInteger = .some(100)

Use where right before the body 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.

PDF conversion courtesy of www.appsdissected.com

 1 func anyCommonElements<T: Sequence, U: Sequence>(_
lhs: T, _ rhs: U) -> Bool
2 where T.Element: Equatable, T.Element ==
U.Element
3 {
4 for lhsItem in lhs {
5 for rhsItem in rhs {
6 if lhsItem == rhsItem {
7 return true
8 }
9 }
10 }
11 return false
12 }
13 anyCommonElements([1, 2, 3], [3])

EXPERIMENT

Modify the anyCommonElements(_:_:) function to make a function that

returns an array of the elements that any two sequences have in common.

Writing <T: Equatable> is the same as writing <T> ... where T:

Equatable.

PDF conversion courtesy of www.appsdissected.com

Language Guide

PDF conversion courtesy of www.appsdissected.com

The Basics

Swift is a new programming language for iOS, macOS, watchOS, and

tvOS 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 three primary collection types,
Array, Set, 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 can’t 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 don’t need to change.

In addition to familiar types, Swift introduces advanced types not

found in Objective-C, such as tuples. Tuples enable you to create and
pass around groupings of values. You can use a tuple to 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”. Using optionals is similar to using nil with
pointers in Objective-C, but they work for any type, not just classes.
Not only are optionals safer and more expressive than nil pointers in
Objective-C, they’re at the heart of many of Swift’s most powerful
features.

Swift is a type-safe language, which means the language helps you

to be clear about the types of values your code can work with. If part
of your code requires a String, type safety prevents you from

PDF conversion courtesy of www.appsdissected.com

passing it an Int by mistake. Likewise, type safety prevents you from
accidentally passing an optional String to a piece of code that
requires a non-optional String. Type safety helps you 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 can’t be changed once it’s 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’re 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:

1 let maximumNumberOfLoginAttempts = 10
2 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.

PDF conversion courtesy of www.appsdissected.com

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

NOTE

If a stored value in your code won’t 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’s 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.

PDF conversion courtesy of www.appsdissected.com

The welcomeMessage variable can now be set to any string value
without error:

welcomeMessage = "Hello"

You can define multiple related variables of the same type on a single
line, separated by commas, with a single type annotation after the
final variable name:

var red, green, blue: Double

NOTE

It’s 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’s 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

Constant and variable names can contain almost any character,
including Unicode characters:

1 let π = 3.14159
2 let 你好 = "你好世界"
3 let 🐶 🐮 = "dogcow"
Constant and variable names can’t contain whitespace characters,
mathematical symbols, arrows, private-use Unicode scalar values, or
line- and box-drawing characters. Nor can they begin with a number,
although numbers may be included elsewhere within the name.

PDF conversion courtesy of www.appsdissected.com

Once you’ve declared a constant or variable of a certain type, you
can’t declare 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.

NOTE

If you need to give a constant or variable the same name as a reserved Swift
keyword, surround the keyword with backticks (`) when using it as a name.
However, 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!":

1 var friendlyWelcome = "Hello!"

2 friendlyWelcome = "Bonjour!"
3 // friendlyWelcome is now "Bonjour!"

Unlike a variable, the value of a constant can’t be changed after it’s

set. Attempting to do so is reported as an error when your code is
compiled:

1 let languageName = "Swift"

2 languageName = "Swift++"
3 // 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
print(_:separator:terminator:) function:

PDF conversion courtesy of www.appsdissected.com

Random documents with unrelated
content Scribd suggests to you:
1.C. The Project Gutenberg Literary Archive Foundation (“the
Foundation” or PGLAF), owns a compilation copyright in the
collection of Project Gutenberg™ electronic works. Nearly all the
individual works in the collection are in the public domain in the
United States. If an individual work is unprotected by copyright law
in the United States and you are located in the United States, we do
not claim a right to prevent you from copying, distributing,
performing, displaying or creating derivative works based on the
work as long as all references to Project Gutenberg are removed. Of
course, we hope that you will support the Project Gutenberg™
mission of promoting free access to electronic works by freely
sharing Project Gutenberg™ works in compliance with the terms of
this agreement for keeping the Project Gutenberg™ name associated
with the work. You can easily comply with the terms of this
agreement by keeping this work in the same format with its attached
full Project Gutenberg™ License when you share it without charge
with others.

1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.

1.E. Unless you have removed all references to Project Gutenberg:

1.E.1. The following sentence, with active links to, or other

immediate access to, the full Project Gutenberg™ License must
appear prominently whenever any copy of a Project Gutenberg™
work (any work on which the phrase “Project Gutenberg” appears,
or with which the phrase “Project Gutenberg” is associated) is
accessed, displayed, performed, viewed, copied or distributed:
 This eBook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this eBook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.

1.E.2. If an individual Project Gutenberg™ electronic work is derived

from texts not protected by U.S. copyright law (does not contain a
notice indicating that it is posted with permission of the copyright
holder), the work can be copied and distributed to anyone in the
United States without paying any fees or charges. If you are
redistributing or providing access to a work with the phrase “Project
Gutenberg” associated with or appearing on the work, you must
comply either with the requirements of paragraphs 1.E.1 through
1.E.7 or obtain permission for the use of the work and the Project
Gutenberg™ trademark as set forth in paragraphs 1.E.8 or 1.E.9.

1.E.3. If an individual Project Gutenberg™ electronic work is posted

with the permission of the copyright holder, your use and distribution
must comply with both paragraphs 1.E.1 through 1.E.7 and any
additional terms imposed by the copyright holder. Additional terms
will be linked to the Project Gutenberg™ License for all works posted
with the permission of the copyright holder found at the beginning
of this work.

1.E.4. Do not unlink or detach or remove the full Project

Gutenberg™ License terms from this work, or any files containing a
part of this work or any other work associated with Project
Gutenberg™.

1.E.5. Do not copy, display, perform, distribute or redistribute this

electronic work, or any part of this electronic work, without
prominently displaying the sentence set forth in paragraph 1.E.1
with active links or immediate access to the full terms of the Project
Gutenberg™ License.

1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.

1.E.7. Do not charge a fee for access to, viewing, displaying,

performing, copying or distributing any Project Gutenberg™ works
unless you comply with paragraph 1.E.8 or 1.E.9.

1.E.8. You may charge a reasonable fee for copies of or providing

access to or distributing Project Gutenberg™ electronic works
provided that:

• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
 about donations to the Project Gutenberg Literary Archive
Foundation.”

• You provide a full refund of any money paid by a user who

notifies you in writing (or by e-mail) within 30 days of receipt
that s/he does not agree to the terms of the full Project
Gutenberg™ License. You must require such a user to return or
destroy all copies of the works possessed in a physical medium
and discontinue all use of and all access to other copies of
Project Gutenberg™ works.

• You provide, in accordance with paragraph 1.F.3, a full refund of

any money paid for a work or a replacement copy, if a defect in
the electronic work is discovered and reported to you within 90
days of receipt of the work.

• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.

1.E.9. If you wish to charge a fee or distribute a Project Gutenberg™

electronic work or group of works on different terms than are set
forth in this agreement, you must obtain permission in writing from
the Project Gutenberg Literary Archive Foundation, the manager of
the Project Gutenberg™ trademark. Contact the Foundation as set
forth in Section 3 below.

1.F.

1.F.1. Project Gutenberg volunteers and employees expend

considerable effort to identify, do copyright research on, transcribe
and proofread works not protected by U.S. copyright law in creating
the Project Gutenberg™ collection. Despite these efforts, Project
Gutenberg™ electronic works, and the medium on which they may
be stored, may contain “Defects,” such as, but not limited to,
incomplete, inaccurate or corrupt data, transcription errors, a
copyright or other intellectual property infringement, a defective or
damaged disk or other medium, a computer virus, or computer
codes that damage or cannot be read by your equipment.

1.F.2. LIMITED WARRANTY, DISCLAIMER OF DAMAGES - Except for

the “Right of Replacement or Refund” described in paragraph 1.F.3,
the Project Gutenberg Literary Archive Foundation, the owner of the
Project Gutenberg™ trademark, and any other party distributing a
Project Gutenberg™ electronic work under this agreement, disclaim
all liability to you for damages, costs and expenses, including legal
fees. YOU AGREE THAT YOU HAVE NO REMEDIES FOR
NEGLIGENCE, STRICT LIABILITY, BREACH OF WARRANTY OR
BREACH OF CONTRACT EXCEPT THOSE PROVIDED IN PARAGRAPH
1.F.3. YOU AGREE THAT THE FOUNDATION, THE TRADEMARK
OWNER, AND ANY DISTRIBUTOR UNDER THIS AGREEMENT WILL
NOT BE LIABLE TO YOU FOR ACTUAL, DIRECT, INDIRECT,
CONSEQUENTIAL, PUNITIVE OR INCIDENTAL DAMAGES EVEN IF
YOU GIVE NOTICE OF THE POSSIBILITY OF SUCH DAMAGE.

1.F.3. LIMITED RIGHT OF REPLACEMENT OR REFUND - If you

discover a defect in this electronic work within 90 days of receiving
it, you can receive a refund of the money (if any) you paid for it by
sending a written explanation to the person you received the work
from. If you received the work on a physical medium, you must
return the medium with your written explanation. The person or
entity that provided you with the defective work may elect to provide
a replacement copy in lieu of a refund. If you received the work
electronically, the person or entity providing it to you may choose to
give you a second opportunity to receive the work electronically in
lieu of a refund. If the second copy is also defective, you may
demand a refund in writing without further opportunities to fix the
problem.

1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.

1.F.5. Some states do not allow disclaimers of certain implied

warranties or the exclusion or limitation of certain types of damages.
If any disclaimer or limitation set forth in this agreement violates the
law of the state applicable to this agreement, the agreement shall be
interpreted to make the maximum disclaimer or limitation permitted
by the applicable state law. The invalidity or unenforceability of any
provision of this agreement shall not void the remaining provisions.

1.F.6. INDEMNITY - You agree to indemnify and hold the Foundation,

the trademark owner, any agent or employee of the Foundation,
anyone providing copies of Project Gutenberg™ electronic works in
accordance with this agreement, and any volunteers associated with
the production, promotion and distribution of Project Gutenberg™
electronic works, harmless from all liability, costs and expenses,
including legal fees, that arise directly or indirectly from any of the
following which you do or cause to occur: (a) distribution of this or
any Project Gutenberg™ work, (b) alteration, modification, or
additions or deletions to any Project Gutenberg™ work, and (c) any
Defect you cause.

Section 2. Information about the Mission

of Project Gutenberg™
Project Gutenberg™ is synonymous with the free distribution of
electronic works in formats readable by the widest variety of
computers including obsolete, old, middle-aged and new computers.
It exists because of the efforts of hundreds of volunteers and
donations from people in all walks of life.

Volunteers and financial support to provide volunteers with the

assistance they need are critical to reaching Project Gutenberg™’s
goals and ensuring that the Project Gutenberg™ collection will
remain freely available for generations to come. In 2001, the Project
Gutenberg Literary Archive Foundation was created to provide a
secure and permanent future for Project Gutenberg™ and future
generations. To learn more about the Project Gutenberg Literary
Archive Foundation and how your efforts and donations can help,
see Sections 3 and 4 and the Foundation information page at
www.gutenberg.org.

Section 3. Information about the Project

Gutenberg Literary Archive Foundation
The Project Gutenberg Literary Archive Foundation is a non-profit
501(c)(3) educational corporation organized under the laws of the
state of Mississippi and granted tax exempt status by the Internal
Revenue Service. The Foundation’s EIN or federal tax identification
number is 64-6221541. Contributions to the Project Gutenberg
Literary Archive Foundation are tax deductible to the full extent
permitted by U.S. federal laws and your state’s laws.

The Foundation’s business office is located at 809 North 1500 West,

Salt Lake City, UT 84116, (801) 596-1887. Email contact links and up
to date contact information can be found at the Foundation’s website
and official page at www.gutenberg.org/contact

Section 4. Information about Donations to

the Project Gutenberg Literary Archive
Foundation
Project Gutenberg™ depends upon and cannot survive without
widespread public support and donations to carry out its mission of
increasing the number of public domain and licensed works that can
be freely distributed in machine-readable form accessible by the
widest array of equipment including outdated equipment. Many
small donations ($1 to $5,000) are particularly important to
maintaining tax exempt status with the IRS.

The Foundation is committed to complying with the laws regulating

charities and charitable donations in all 50 states of the United
States. Compliance requirements are not uniform and it takes a
considerable effort, much paperwork and many fees to meet and
keep up with these requirements. We do not solicit donations in
locations where we have not received written confirmation of
compliance. To SEND DONATIONS or determine the status of
compliance for any particular state visit www.gutenberg.org/donate.

While we cannot and do not solicit contributions from states where

we have not met the solicitation requirements, we know of no
prohibition against accepting unsolicited donations from donors in
such states who approach us with offers to donate.

International donations are gratefully accepted, but we cannot make

any statements concerning tax treatment of donations received from
outside the United States. U.S. laws alone swamp our small staff.

Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.

Section 5. General Information About

Project Gutenberg™ electronic works
Professor Michael S. Hart was the originator of the Project
Gutenberg™ concept of a library of electronic works that could be
freely shared with anyone. For forty years, he produced and
distributed Project Gutenberg™ eBooks with only a loose network of
volunteer support.
Project Gutenberg™ eBooks are often created from several printed
editions, all of which are confirmed as not protected by copyright in
the U.S. unless a copyright notice is included. Thus, we do not
necessarily keep eBooks in compliance with any particular paper
edition.

Most people start at our website which has the main PG search
facility: www.gutenberg.org.

This website includes information about Project Gutenberg™,

including how to make donations to the Project Gutenberg Literary
Archive Foundation, how to help produce our new eBooks, and how
to subscribe to our email newsletter to hear about new eBooks.
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