| Aug | SEP | Oct |
| 16 | ||
| 2020 | 2021 | 2022 |
COLLECTED BY
Collection: Common Crawl
Package.swift,
defines the package’s name and its contents
using the PackageDescription module.
A package has one or more targets.
Each target specifies a product
and may declare one or more dependencies.
PlayingCard, Suit, and Rank types.
●FisherYates - Defines an extension that implements the shuffle() and shuffleInPlace() methods.
●DeckOfPlayingCards - Defines a Deck type that shuffles and deals an array of PlayingCard values.
●Dealer - Defines an executable that creates a DeckOfPlayingCards, shuffles it, and deals the first 10 cards.
You can build and run the complete example
by downloading the source code of the Dealer project from GitHub
and running the following commands:
$ git clone https://github.com/apple/example-package-dealer.git
$ cdexample-package-dealer
$ swift run Dealer
PlayingCard target defines the PlayingCard type,
which consists of a Suit enumeration value (Clubs, Diamonds, Hearts, Spades)
and a Rank enumeration value (Ace, Two, Three, …, Jack, Queen, King).
public enum Rank: Int {
case two = 2
case three, four, five, six, seven, eight, nine, ten
case jack, queen, king, ace
}
public enum Suit: String {
case spades, hearts, diamonds, clubs
}
public struct PlayingCard {
let rank: Rank
let suit: Suit
}
Sources/<target-name> directory.
example-package-playingcard
├── Sources
│ └── PlayingCard
│ ├── PlayingCard.swift
│ ├── Rank.swift
│ └── Suit.swift
└── Package.swift
PlayingCard target does not produce an executable,
it can be described as a library.
A library is a target that builds a module which can be imported by other packages.
By default, a library module exposes all of the public types and methods
declared in source code located in the Sources/<target-name> directory.
Run swift build to start the Swift build process.
If everything worked correctly,
it will compile the Swift module for PlayingCard.
The complete code for the PlayingCard package can be found at
https://github.com/apple/example-package-playingcard.
FisherYates.
Unlike PlayingCard, this module does not define any new types.
Instead, it extends an existing type –
specifically the Collection and MutableCollection protocols –
to add the shuffled() method
and its mutating counterpart shuffle().
The implementation of shuffle() uses
the Fisher-Yates algorithm
to randomly permute the elements in a collection.
Instead of using the random number generator provided by the Swift standard library,
this method calls a function imported from a system module.
For this function to be compatible with both macOS and Linux,
the code uses build configuration statements.
In macOS, the system module is Darwin,
which provides the arc4random_uniform(_:) function.
In Linux, the system module is Glibc,
which provides the random() function:
#if os(Linux)
import Glibc
#else
import Darwin.C
#endif
public extension MutableCollection where Index == Int {
mutating func shuffle() {
if count <= 1 { return }
for i in 0..<count - 1 {
#if os(Linux)
let j = Int(random() % (count - i)) + i
#else
let j = Int(arc4random_uniform(UInt32(count - i))) + i
#endif
swapAt(i, j)
}
}
}
FisherYates package can be found at
https://github.com/apple/example-package-fisheryates.
DeckOfPlayingCards package brings the previous two packages together:
It defines a Deck type
that uses the shuffle() method from FisherYates
on an array of PlayingCard values.
To use the FisherYates and PlayingCards modules,
the DeckOfPlayingCards package must declare their packages as dependencies
in its Package.swift manifest file.
// swift-tools-version:4.0
import PackageDescription
let package = Package(
name: "DeckOfPlayingCards",
products: [
.library(name: "DeckOfPlayingCards", targets: ["DeckOfPlayingCards"]),
],
dependencies: [
.package(url: "https://github.com/apple/example-package-fisheryates.git", from: "2.0.0"),
.package(url: "https://github.com/apple/example-package-playingcard.git", from: "3.0.0"),
],
targets: [
.target(
name: "DeckOfPlayingCards",
dependencies: ["FisherYates", "PlayingCard"]),
.testTarget(
name: "DeckOfPlayingCardsTests",
dependencies: ["DeckOfPlayingCards"]),
]
)
FisherYates dependency,
the most recent version with a major version equal to 2(for example, 2.0.4) will be used.
Similarly, the PlayingCard dependency will use the most recent version with a major version equal to 3.
When the swift build command is run,
the Package Manager downloads all of the dependencies,
compiles them,
and links them to the package module.
This allows DeckOfPlayingCards
to access the public members of its dependent modules
with import statements.
You can see the downloaded sources in the .build/checkouts directory at the root of your project,
and intermediate build products in the .build directory at the root of your project.
The complete code for the DeckOfPlayingCards package can be found at
https://github.com/apple/example-package-deckofplayingcards.
Dealer module.
The Dealer module depends on the DeckOfPlayingCards package,
which in turn depends on the PlayingCard and FisherYates packages.
However, because the Swift Package Manager automatically resolves transitive dependencies,
you only need to declare the DeckOfPlayingCards package as a dependency.
// swift-tools-version:4.0
import PackageDescription
let package = Package(
name: "dealer",
products: [
.executable(name: "Dealer", targets: ["Dealer"]),
],
dependencies: [
.package(url: "https://github.com/apple/example-package-deckofplayingcards.git", from: "3.0.0"),
],
targets: [
.target(
name: "Dealer",
dependencies: ["DeckOfPlayingCards"]),
]
)
Dealer module’s main.swift file,
the Deck type from DeckOfPlayingCards
and the PlayingCard type from PlayingCard are referenced.
Although the shuffle() method on the Deck type
uses the FisherYates module internally,
that module does not need to be imported in main.swift.
import DeckOfPlayingCards
let numberOfCards = 10
var deck = Deck.standard52CardDeck()
deck.shuffle()
for _ in 1...numberOfCards {
guard let card = deck.deal() else {
print("No More Cards!")
break
}
print(card)
}
main.swift in its directory
produces an executable.
Running the swift build command
starts the Swift build system
to produce the Dealer executable,
which can be run from the .build/debug directory.
$ swift build
$ ./.build/debug/Dealer
♠︎6
♢K♢2♡8♠︎7
♣︎10
♣︎5
♢A♡Q♡7Dealer package can be found at
https://github.com/apple/example-package-dealer.