Index

A

• argument labels
  • adding, to function / Argument Labels
  • excluding, from function / Excluding Argument Labels
• arithmetic operators
  • standard arithmetic operators / Standard Arithmetic Operators
  • remainder operator / Remainder Operator
  • unary minus operator / Unary minus Operator
• arrays
  • about / Arrays
  • working with / Workingarraysworking with with Arrays, Activity A: Working with Arrays
  • index / Index
  • ArraySlice / ArraySlice
• ArraySlice
  • about / ArraySlice
• assignment operator
  • about / Assignment Operator
  • compound assignment operator / Compound Assignment Operators

B

• BidirectionalCollection / Workingarraysworking with with Arrays
• bitwise operators
  • about / Bitwise Operators
• Boolean data type
  • about / Boolean
• Bool value
  • about / Boolean
• branching
  • about / Branching
  • if statement / The if Statement
  • condition lists / Condition Lists
  • switch statement / The switch Statement
• break keyword
  • about / The break Keyword
  • using / The break Keyword

C

• CamelCase
  • about / Activity C: CamelCase
  • using / Activity C: CamelCase
• Character data type
  • about / Character
  • values, assigning / Assigning a Character
  • Character literal, constructing / Constructing a Character Literal
• classes
  • about / Object-Oriented Principles, Illustration
  • versus, structs / Classes Versus Structs, Illustration
  • defining / Defining Classes and Structures
• closed range operator
  • about / Closed Range Operator
• closures
  • about / Functions as Parameters, Closures
• code
  • converting, from if to switch / Activity B: Converting Code from if to switch
• comparison operators
  • about / Comparison Operators
  • equality / Equality
  • inequality / Inequality, Comparison between Two Values
• compound assignment operators
  • about / Compound Assignment Operators
• conditional unwrapping
  • about / Conditionally Unwrapping Optionals, Using Optionals
• continue statement
  • using / The continue Control Transfer Statement
• CountedSet / Activity C: Using Dictionaries
• customer class
  • creating / Activity C: Creating a Customer Struct and Class, Challenge
• customer struct
  • creating / Activity C: Creating a Customer Struct and Class, Challenge

D

• @discardableResult
  • about / Using @discardableResult
  • using / Using @discardableResult
• data types, Swift
  • about / Swift Data Types
  • numeric data types / Numeric Data Types
  • Boolean / Boolean
  • Character / Character
  • string / String
  • working with / Activity C: Data Type Summary
• dictionaries
  • about / Dictionaries
  • working with / Workingdictionariesworking with with Dictionaries
  • using / Activity C: Using Dictionaries
• do…catch
  • about / The do…catch Statement
  • implementing / The do…catch Statement

E

• endIndex / Index
• enum
  • about / Enums
  • basic syntax / Basic Enum Syntax
  • raw values / Enum with Raw Values
  • using / Activity D: Using Swift Enums
• Equatable / Sets
• error handling
  • about / Error Handling
  • do…catch statement / The do…catch Statement
  • multiple catch blocks / Multiple catch Blocks
  • do without catch, using / Using do without catch
  • guard statement / The guard Statement
• exception handling
  • about / Activity B: Exception Handling

F

• fallthrough keyword
  • about / The fallthrough Keyword
• filter method
  • about / filter
  • using / Usingfilter methodusing the filter Method
• flatMap method
  • about / flatMap
  • using / Using flatMap methodusingthe flatMap Function
• force unwrapped variable
  • about / Declaring an Optional
• force unwrapping
  • about / Force Unwrapping an Optional
• for…in statement
  • about / The for…in Statement
  • objects, iterating over / Iterating over Objects
  • array objects with index, iterating over / Iterating over Array Objects with index
  • for loop where clause / The for Loop where Clause
  • break control transfer statement / The break Control Transfer Statement
  • continue control transfer statement / The continue Control Transfer Statement
• functional methods
  • about / Functional Methods
  • filter / filter
  • map / map
  • flatMap / flatMap
  • reduce / reduce
• functional programming
  • implementing / Activity A: Implementing Functional Programming
• function attributes
  • about / Function Attributes
• functions
  • about / Functions
  • defining / Defining a Function
  • basic syntax / Defining a Function
  • argument labels, adding / Argument Labels
  • argument labels, excluding / Excluding Argument Labels
  • parameter default values, providing / Parameter Default Values
  • implementing / Activity A: Implementing a Function
  • values, returning from / Returning Values from Functions
  • @discardableResult, using / Using @discardableResult
  • function attributes / Function Attributes
  • variadic parameters / Variadic Parameters
  • inout parameters / inout Parameters
  • recursion / Recursion
  • as parameters / Functions as Parameters
  • closures / Closures
  • creating, for receiving content from asynchronous web service call / Creating a Function to Receive Content from an Asynchronous Web Service Call
• function type
  • about / Function Type

G

• guard statement
  • about / The guard Statement
  • using / The guard Statement

H

• half-open range operator
  • about / Half-Open Range Operator
• Hashable / Sets
• Hello, World program
  • about / Hello, World!

I

• if statement
  • about / Branching, The if Statement
  • implementing / The if Statement
  • implementing, with multiple conditions / Condition Lists
  • optional unwrapping / Optional Unwrapping with if
• index type, arrays
  • about / Index
  • common operations, utilizing / Utilizing Common Operations with Index
• indices of character, string
  • identifying / Activity A: All Indices of a Character
• infer data type / Type Inference
• inout parameters
  • about / inout Parameters

L

• lazy operations
  • about / Lazy Operations
  • lazy sequence / Lazy Operations, Lazy Sequences
  • implementing / Lazy Sequences
  • Sequence internals / Sequence Internals
  • creating / Creating Lazy Operations
  • sequence functions / sequence(first:next:), sequence(state:next:)
• lazy version, of method
  • implementing / Activity B: Implementing a Lazy Version of a Method
• logical operators
  • about / Logical Operators
• loops
  • about / Loops
  • for…in statement / The for…in Statement
  • while loop / The while Loop
  • implementing / Activity C: Implementing Loops

M

• map method
  • about / map
  • using / map
• multiple catch blocks
  • about / Multiple catch Blocks
• MutableCollection / Workingarraysworking with with Arrays

N

• nil-coalescing operator
  • about / Nil-Coalescing Operator
• NSRange
  • converting, to Range / Converting NSRange to Range
• numeric data types
  • about / Numeric Data Types
  • Int on 64-bit platform, versus 32-bit patform / Int on 64-Bit Versus 32-Bit Platforms
  • built-in numeric data types / Built-In Numeric Data Types
  • appropriate numeric data type, selecting / Choosing the Appropriate Numeric Data Type
  • Integer variables, declaring / Declaring and Assigning Integer Variables
  • Integer variables, assigning / Declaring and Assigning Integer Variables
  • floating-point numbers, declaring / Declaring and Assigning Floating Point Numbers
  • floating-point numbers, assigning / Declaring and Assigning Floating Point Numbers
  • numeric literal grouping / Numeric Literal Grouping
  • numeric type conversions / Numeric Type Conversions
  • working with / Using Numeric Types

O

• one-sided range operator
  • about / One-Sided Range Operator
• optional
  • about / Optionals
  • declaring / Declaring an Optional
  • working with / Working with Optionals
  • nil values / Optional nil Values
  • values, accessing / Accessing Optional Values
  • force unwrapping / Force Unwrapping an Optional
  • conditional unwrapping / Conditionally Unwrapping Optionals, Using Optionals

R

• RandomAccessCollection / Workingarraysworking with with Arrays
• range operators
  • about / Range Operators
  • closed range operator / Closed Range Operator
  • half open range operator / Half-Open Range Operator
  • one-sided range operator / One-Sided Range Operator
• RangeReplaceableCollection / Workingarraysworking with with Arrays
• ranges, of substring
  • finding / Activity B-1: All Ranges of a Substring
• recursion
  • about / Recursion
• reduce method
  • about / reduce
  • using / Using reduce methodusingthe reduce Function

S

• SetAlgebra / Sets
• sets
  • about / Sets
  • working with / Working setsworking withwith Sets
  • combining / Combining Sets
  • comparing / Comparing Sets
  • duplicates, removing from sequence / Activity B: Removing Duplicates from a Sequence
• slices
  • creating / Creating Slices
  • creating, range operators used / Creating Slices Using Range Operators
• startIndex / Index
• string
  • about / String
  • instantiating / Instantiating a String
  • concatenation / String Concatenation
  • Characters, extracting / Extracting Characters
  • length, obtaining / String Length
  • indices of character, identifying / Activity A: All Indices of a Character
  • using / Using Strings
  • creating / Creating Strings
  • common operations, implementing / Common Operations
  • text operations, implementing / Implementing stringtext operations, implementingExtra Text Operations on a String
  • ranges of substring, finding / Activity B-1: All Ranges of a Substring
  • number of spaces, counting / Activity B-2: Counting Words, Sentences, and Paragraphs
• string fundamentals
  • about / String Fundamentals
  • character / Character
  • collection / Collection
  • index / Index, Working with String Index
  • debugging / Debugging
• String index
  • working with / Working with String Index
• StringProtocol
  • about / Substring
• structs
  • about / Object-Oriented Principles
  • defining / Defining Classes and Structures
• substrings
  • about / Substring
  • creating / Creating Substrings
  • parsing / Parsing Strings
  • NSRange, converting to Range / Converting NSRange to Range
• Swift
  • program structure / Swift Program Structure, Hello, World!
  • basic language syntax / Swift Program Structure
  • Hello, World program / Hello, World!
  • variables / Swift Variables and Constants
  • constants / Variables Versus Constants
  • type inference / Type Inference
  • optional / Optionals
  • data types / Swift Data Types
  • branching / Branching
  • object-oriented features / Object-Oriented Features
  • object-oriented principles / Object-Oriented Principles
• Swift collections
  • arrays / Arrays
• Swift guard statement
  • about / The Swift guard Statement
• Swift operators
  • about / Swift Operators
  • categories / Swift Operators
  • assignment operator / Assignment Operator
  • arithmetic operators / Standard Arithmetic Operators
  • comparison operators / Comparison Operators
  • ternary conditional operator / Ternary Conditional Operator
  • logical operators / Logical Operators
  • bitwise operators / Bitwise Operators
  • nil-coalescing operator / Nil-Coalescing Operator
  • range operators / Range Operators
  • working with / Activity A: Operators
• Swift variables
  • declaring / Declaring Swift Variables
  • versus, Swift constants / Variables Versus Constants
  • variable naming / Variable Naming
  • working with / Working with Variables, Activity B: Variable Summary
• Swifty code
  • about / Swifty Code
  • naming / Naming
  • code organization / Organizing Code
  • miscellaneous / Miscellaneous
  • writing / WritingSwifty codewriting Swifty Code
• switch statement
  • about / The switch Statement
  • syntax rules / switch Statement Rules
  • break keyword / The break Keyword
  • fallthrough keyword / The fallthrough Keyword
  • multiple patterns, matching in single case / Multiple Patterns in a Single Case
  • where statement, using within case / Using the where Statement within case
  • optionals, evaluating with / Evaluating Optionals with a switch Statement

T

• ternary conditional operator
  • about / Ternary Conditional Operator
• try? keyword
  • using / Using do without catch
• tuples
  • about / Tuples
  • creating / Creating a Tuple
• type-safe language
  • about / Type Inference
• type cast
  • force unwrapping / Force Unwrapping an Optional
• type inference
  • about / Type Inference

U

• UnfoldSequence / Activity B: Implementing a Lazy Version of a Method

V

• variable naming
  • about / Variable Naming
• variadic parameters
  • about / Variadic Parameters

W

• while loop
  • about / The while Loop
  • syntax rules / The while Loop
  • using / The while Loop
  • repeat…while loop / The repeat…while Loop