 	// Sieving Properly then filtering for primes is the same as just Sieving, right?
 	return sieveProperly(n.getPositive).filter(isPrime) == sieveProperly(n.getPositive)
 }
+
+//; # One More Thing
+
+//: When working with failing tests, it's often tough to be able to replicate the exact conditions
+//: that cause a failure or a bug.  With SwiftCheck, that is now a thing of the past.  The framework
+//: comes with a replay mechanism that allows the arguments that lead to a failing test to be generated
+//: in exactly the same order, with exactly the same values, as they did the first time.  When a test
+//: fails, SwiftCheck will present a helpful message that looks something like this in Xcode:
+
+//: > failed - Falsifiable; Replay with 123456789 123456789
+
+//: Or this message in your log:
+
+//: > Pass the seed values 123456789 123456789 to replay the test.
+
+//: These are called *seeds*, and they can be fed back into the property that generated them to 
+//: activate the replay feature.  For example, here's an annoying test to debug because it only fails
+//: every so often on one particular value:
+
+reportProperty("Screw this value in particular") <- forAll { (n : UInt) in
+	if (n == 42) {
+		return false
+	}
+
+	return true
+}
+
+//: But with a replay seed of (1391985334, 382376411) we can always reproduce the failure because
+//: 42 will always be generated as the first value.  We've turned on verbose mode to demonstrate this.
+
+/// By passing this argument to the test, SwiftCheck will automatically use the given seed values and
+/// size to completely replicate a particular set of values that caused the first test to fail.
+let replayArgs = CheckerArguments(replay: (StdGen(1391985334, 382376411), 100))
+reportProperty("Replay", arguments: replayArgs) <- forAll { (n : UInt) in
+	if (n == 42) {
+		return false
+	}
+	return true
+}.verbose
 
 //: # Conclusion
 

	// Here we use `emailGen` to generate our cases out of convenience, but there are much 
	// more efficient ways we could have done this.  See `Modifiers.swift` for examples.
	static func shrink(tt : ArbitraryEmail) -> [ArbitraryEmail] {
		return emailGen.suchThat({ $0.unicodeScalars.count <= (tt.getEmail.unicodeScalars.count / 2) }) // Halve the size of the input address for efficient shrinking.
						.proliferateNonEmpty() // Proliferate an array 
						.generate // Generate
						.map(ArbitraryEmail.init) // Then wrap in our Modifier Type
	}
}


//:
//:     *** Failed! Proposition: All Prime
//:     Falsifiable (after 11 tests and 2 shrinks):
//:     Positive( 4 ) // or Positive( 9 )
//:     0
//:
//: What's wrong here?
