The Swift Programming Language Swift 5 7 Apple

Inc. install download

https://ebookmeta.com/product/the-swift-programming-language-
swift-5-7-apple-inc/

Download more ebook from https://ebookmeta.com

We believe these products will be a great fit for you. Click
the link to download now, or visit ebookmeta.com
to discover even more!

Deep Learning with Swift for TensorFlow Differentiable

Programming with Swift 1st Edition Rahul Bhalley

https://ebookmeta.com/product/deep-learning-with-swift-for-
tensorflow-differentiable-programming-with-swift-1st-edition-
rahul-bhalley/

Swift 3 Protocol Oriented Programming Hoffman Jon

https://ebookmeta.com/product/swift-3-protocol-oriented-
programming-hoffman-jon/

Develop in Swift Explorations Xcode 13 2021 13th

Edition Apple Education

https://ebookmeta.com/product/develop-in-swift-explorations-
xcode-13-2021-13th-edition-apple-education/

Community based Learning and Social Movements Popular

Education in a Populist Age 1st Edition Marjorie Mayo

https://ebookmeta.com/product/community-based-learning-and-
social-movements-popular-education-in-a-populist-age-1st-edition-
marjorie-mayo/
Mobilizing Narratives Narrating Injustices of Im
Mobility 1st Edition Hager Ben Driss (Editor)

https://ebookmeta.com/product/mobilizing-narratives-narrating-
injustices-of-im-mobility-1st-edition-hager-ben-driss-editor/

Could It Be B12 ? Pediatric Edition: What Every Parent

Needs to Know about Vitamin B12 Deficiency ( What's
Wrong with My Child ?: From Neurological and
Developmental Disabilities to Autism...How to Protect
Your Child from B12 Deficiency ) Sally Pacholok
https://ebookmeta.com/product/could-it-be-b12-pediatric-edition-
what-every-parent-needs-to-know-about-vitamin-b12-deficiency-
whats-wrong-with-my-child-from-neurological-and-developmental-
disabilities-to-autism-how-to-pr/

Spectres of Reparation in South Africa 1st Edition Jaco

Barnard Naudé

https://ebookmeta.com/product/spectres-of-reparation-in-south-
africa-1st-edition-jaco-barnard-naude/

Acing the CCNA Exam (MEAP V03) Jeremy Mcdowell

https://ebookmeta.com/product/acing-the-ccna-exam-
meap-v03-jeremy-mcdowell/

A Broad Guide to Reading and Comprehension 1st Edition

Mahmoud Sultan Nafa

https://ebookmeta.com/product/a-broad-guide-to-reading-and-
comprehension-1st-edition-mahmoud-sultan-nafa/
Unraveling Remaking Personhood in a Neurodiverse Age
1st Edition Wolf-Meyer

https://ebookmeta.com/product/unraveling-remaking-personhood-in-
a-neurodiverse-age-1st-edition-wolf-meyer/
Welcome to Swift
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 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.
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.
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
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.

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:
 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 shoppingList = ["catfish", "water", "tulips"]

2 shoppingList[1] = "bottle of water"
3

4 var occupations = [
5 "Malcolm": "Captain",
6 "Kaylee": "Mechanic",

7 ]
8 occupations["Jayne"] = "Public Relations"

Arrays automatically grow as you add elements.

1 shoppingList.append("blue paint")

2 print(shoppingList)

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

1 let emptyArray: [String] = []

2 let emptyDictionary: [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.

1 shoppingList = []
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
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.
 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?"

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

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.

 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 })
 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.

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.
 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 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()
 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.
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)
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.
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"
 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.
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
 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.
 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 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.
 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.
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.
 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.
 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.

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?

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.

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.

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.
 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")

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.
 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.
 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.
Discovering Diverse Content Through
Random Scribd Documents
Mr. Thornycroft, who had been looking from the window over the
sea, lying hot and clear and beautiful this morning, turned and stood
before her; his fair, handsome face grave, his towering form raised
to its full height, his voice, as he spoke, impressive in its calm
decision.

"Lady Ellis, understand one thing--that this is a matter you must not
interfere in. The housekeeping at the Red Court Farm that you are
pleased to find cause of fault with--is an established rule; so to say,
an institution. It cannot be changed. Sinnett will conduct it as
hitherto without trouble to or interference from yourself. Whenever it
does not please you to sit down to table, there are other rooms in
which you can order your dinner served."

"And suppose I say that I must exert my right of authority--my

privilege of controlling the dinners?" she rejoined, her voice getting
just a little harsh with the opposition.

"You cannot say it. I am master of my own house and my own

table."

"You have made me the mistress!"

"Just so; but not to alter the established usages."

Lady Ellis tapped her foot on the soft carpet. "Do you consider that
there is any reason in keeping so large a table?"

"There may or may not be. My pleasure is that it shall be kept. My

sons have been brought up to it; they would not have it curtailed."

"I think your sons have been brought up to a great deal that is
unfitting. One would think they were lords."

"Handsome, noble fellows!" aspirated the justice, with perhaps a

little spice of aggravation. "There are not many lords that can match
them."
My lady bit her thin lips, a sure sign of rising temper. "It seems to
me to be my duty, Mr. Thornycroft, exercising the authority you have
vested in me by making me your wife, to control the extravagance
hitherto running riot. Opposition, ill-feeling, in the house will not be
seemly."

"Neither will I have it," put in the justice.

"I do not see that it can be avoided. I give certain orders. Sinnett,
acting under you, opposes them. What can the result be but
unseemly contention? How would you avoid it, I ask?"

"By going to live in one of the cottages on the heath, and leaving
Isaac--I mean Richard--master of the Red Court Farm."

He spoke promptly--like a man whose mind is fully made up. The

prospect of living in a cottage on the heath nearly took my lady's
breath away.

"Mr. Thornycroft!" she passionately exclaimed, and then her tone

changed to one of peevish remonstrance: "why do you bring up
impossibilities? A cottage on the heath!"

Mr. Thornycroft brought down his hand, not in anger but emphasis,
on the small breakfast table.

"Were the order of the Red Court upset by unnecessary interference

on your part--were I to find that I could be no longer master of it
without being subjected to continual opposition, I should surely quit
it. If a cottage on the heath were distasteful to you I would take
lodgings at Jutpoint."

Lady Ellis sipped her coffee. It did not appear safe to say more. A
cottage on the heath, or lodgings at Jutpoint!

"I only wished to put a stop to unnecessary extravagance," she said,

in a tone of conciliation.
"No doubt. I give you credit for good motives, of course; but these
things must be left to me. The same gentlemen who dined here
yesterday evening are coming to supper this. I have made out the
bill of fare myself, and given it to Sinnett."

"Coming again to-night!" she could not help exclaiming.

"To atone for the shortcomings of yesterday's dinner," spoke the

justice. "I never had occasion to feel ashamed of my table before."

"I cannot think what possible pleasure you can find in the society of
such men," she said, after a pause. "Look at them, coming out to
dinner in those rough coats!"

Mr. Thornycroft laughed. "We don't go in often for evening dress at

Coastdown. As to the pleasure, they have been in the habit of sitting
at my table for some years now, madam, and I enjoy the
companionship."

"I fancied you left them early; I thought I saw you cross the garden,
as if coming from the plateau," she said, resolving to speak of the
matter which had so puzzled her.

"We did not leave the dining-room until eleven o'clock."

"Well--it was very strange. I was standing at this window, and

certainly saw some one exactly like you; the same figure, the same
face; but not in the same dress. He seemed to have on gaiters and a
velveteen coat, and a low broad-brimmed hat, very ugly. What
should you say it could have been?"

"I should say that you were dreaming."

"I was wide awake. It was just before that mist came on," she
added.
"Ah, the fault must have lain in the mist. I have known it come as a
mirage occasionally, bringing deception and confusion."

Did he really mean it? It seemed so, for there was seriousness on his
face as he spoke. Quitting the room, he descended the stairs, and
made his way to the fields. In the four-acre mead--as it was called in
common parlance on the farm--he came upon Richard watching the
hay-makers. Richard wished him good morning; abroad early, it was
the first time he had seen his father that day.

"What was the failure, Dick?" asked the justice. "Fog," shortly
answered Richard. "Couldn't see the light."

Mr. Thornycroft nodded.

"Are we to have a repetition, sir, of yesterday's dinner table?"

resumed Richard. "If so, I think the sooner your wife is requested to
take up her residence somewhere else, the better."

"You will not have it again. Sinnett holds my orders, and my wife has
been made aware she does. There's no need for you to put yourself
out."

With the injunction, spoken rather testily, Mr. Thornycroft left him.
But a little later, when he met Isaac, he voluntarily entered on the
subject; hinting his vexation at the past, promising that it would
never again occur, almost as if he were tendering an apology for the
accident.

"I'm afraid I made a mistake, Ikey; I'm afraid I made a mistake; but
I meant it for the best."

It was ever thus. To his second son Mr. Thornycroft's behaviour was
somewhat different from what it was to his eldest. It could not be
said that he paid him more deference: but it was to Isaac he
generally spoke of business, when speaking was needed; if an
opinion was required, Isaac's was sought in preference to Richard's.
It was just as though Isaac had been the eldest son. That Richard
had brought this on himself, by his assumption of authority, was
quite probable: and the little preference seemed to spring from the
justice involuntarily.

The evening supper took place, and the guests were consoled by the
ample table for the scantiness of the previous dinner. My lady was
not invited to join it; nothing appeared further from Mr. Thornycroft's
thoughts than to have ladies at table. She spent a solitary sort of
evening; Mary Anne was at Mrs. Wilkinson's, taking leave of Miss
Derode.

Was it, she asked herself, to go on like this always and always? Had
she become the wife of Justice Thornycroft only to die of the dreary
life at the Red Court Farm? Let us give her her due. When she
married him she did intend to do her duty as an honest woman, and
send ridiculous flirtations, such as that carried on with Robert Lake,
to the winds. But she did not expect to be done to death of ennui.

A short while went on. Nearly open warfare set in between Mary
Anne and her stepmother. To-day my lady would be harsh, exacting,
almost cruel in her rule; tomorrow the girl would be wholly
neglected--suffered to run wild. Mr. Thornycroft saw that things
could not continue thus, and the refrain of the words he had spoken
to Isaac beat ever on his brain, day by day bringing greater force to
them: "I fear I made a mistake; I fear I made a mistake."

One morning Mary Anne astonished the justice by appearing before

him in his bureau, in what she was pleased to call the uncivilized
rooms. He sat there with Mr. Hopley, of Dartfield, some account
books before them. Her dress, a beautiful muslin with a raised blue
spot, was torn out at the gathers and trailed behind her. My lady had
done it in a passion.

"Holloa! what do you do here?" cried the justice, emphatically; and

Mr. Hopley went out whistling, with his hands in his pockets, and
crossed over to stare at the idle dog-cart in the coach-house, as if to
give privacy for the explanation.

She had come with one of her tales of woe. She had come to beg
and pray to be sent to school. What a change! Mr. Thornycroft was
nearly at his wits' end.

Ere the day was over, his wife brought a complaint to him on her
own score: not altogether of Mary Anne. She simply said,
incidentally, that ill-trained young lady was getting quite beyond her
control, and therefore she must wash her hands of her. The
complaint was of her own health; it appeared to be failing her in a
rather remarkable manner, certainly a sudden one. This was true.
She had concluded that the air of Coastdown was inimical to her, she
wished it might be managed for her to live away--say Cheltenham,
or some other healthy place.

How eagerly Mr. Thornycroft caught at the suggestion, he felt

afterwards half ashamed to think of. In matters involving money he
was always liberal, and he at once named a handsome sum per
month that she might enjoy, at Cheltenham, or anywhere else that
pleased her.

END OF VOL. I.
 *** END OF THE PROJECT GUTENBERG EBOOK THE RED COURT
FARM: A NOVEL (VOL. 1 OF 2) ***

Updated editions will replace the previous one—the old editions will
be renamed.

Creating the works from print editions not protected by U.S.

copyright law means that no one owns a United States copyright in
these works, so the Foundation (and you!) can copy and distribute it
in the United States without permission and without paying
copyright royalties. Special rules, set forth in the General Terms of
Use part of this license, apply to copying and distributing Project
Gutenberg™ electronic works to protect the PROJECT GUTENBERG™
concept and trademark. Project Gutenberg is a registered trademark,
and may not be used if you charge for an eBook, except by following
the terms of the trademark license, including paying royalties for use
of the Project Gutenberg trademark. If you do not charge anything
for copies of this eBook, complying with the trademark license is
very easy. You may use this eBook for nearly any purpose such as
creation of derivative works, reports, performances and research.
Project Gutenberg eBooks may be modified and printed and given
away—you may do practically ANYTHING in the United States with
eBooks not protected by U.S. copyright law. Redistribution is subject
to the trademark license, especially commercial redistribution.

START: FULL LICENSE

THE FULL PROJECT GUTENBERG LICENSE
 PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK

To protect the Project Gutenberg™ mission of promoting the free

distribution of electronic works, by using or distributing this work (or
any other work associated in any way with the phrase “Project
Gutenberg”), you agree to comply with all the terms of the Full
Project Gutenberg™ License available with this file or online at
www.gutenberg.org/license.

Section 1. General Terms of Use and

Redistributing Project Gutenberg™
electronic works
1.A. By reading or using any part of this Project Gutenberg™
electronic work, you indicate that you have read, understand, agree
to and accept all the terms of this license and intellectual property
(trademark/copyright) agreement. If you do not agree to abide by all
the terms of this agreement, you must cease using and return or
destroy all copies of Project Gutenberg™ electronic works in your
possession. If you paid a fee for obtaining a copy of or access to a
Project Gutenberg™ electronic work and you do not agree to be
bound by the terms of this agreement, you may obtain a refund
from the person or entity to whom you paid the fee as set forth in
paragraph 1.E.8.

1.B. “Project Gutenberg” is a registered trademark. It may only be

used on or associated in any way with an electronic work by people
who agree to be bound by the terms of this agreement. There are a
few things that you can do with most Project Gutenberg™ electronic
works even without complying with the full terms of this agreement.
See paragraph 1.C below. There are a lot of things you can do with
Project Gutenberg™ electronic works if you follow the terms of this
agreement and help preserve free future access to Project
Gutenberg™ electronic works. See paragraph 1.E below.
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.