Add Shrinking functionality

Author: x-sheep

.gitattributes

@@ -0,0 +1 @@
+*.swift.gyb linguist-language=Swift

.gitignore

@@ -6,3 +6,7 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
+
+/gyb
+/gyb.py
+/__pycache__

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Lennard Sprong
+Copyright (c) 2025 Lennard Sprong. Portions copyright Point-Free, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

Package.resolved

@@ -11,16 +11,17 @@ let package = Package(
             targets: ["PropertyBased"]
         ),
     ],
-    dependencies: [
-        .package(url: "https://github.com/pointfreeco/swift-gen.git", from: "0.4.0"),
-    ],
+    dependencies: [],
     targets: [
-        .target(name: "PropertyBased", dependencies: [
-            .product(name: "Gen", package: "swift-gen"),
-        ]),
+        .target(
+            name: "PropertyBased",
+            dependencies: [],
+            exclude: ["PropertyCheck+Pack.swift.gyb", "Zip.swift.gyb"]
+        ),
         .testTarget(
             name: "PropertyBasedTests",
-            dependencies: ["PropertyBased"]
+            dependencies: ["PropertyBased"],
+            exclude: ["ZipTests.swift.gyb"]
         ),
     ]
 )

Package.swift

@@ -7,7 +7,7 @@ PropertyBased is a Swift 6 library that enables Property-Based Testing in `swift
 
 Property-Based Testing can be used as an alternative for (or in addition to) testing with hardcoded values. Run tests with random values, and easily switch to specific values when debugging a test failure. 
 
-This library uses [swift-gen by Point-Free](https://github.com/pointfreeco/swift-gen) for reproducible random generation.
+This project aims to support all platforms which can run Swift Testing, including platforms without [Foundation](https://developer.apple.com/documentation/foundation) support.
 
 ## Requirements
 
@@ -25,21 +25,20 @@ import Testing
 import PropertyBased
 
 @Test func testDuplication() async {
-  await propertyCheck(input: .int(in: 0...100)) { n in
+  await propertyCheck(input: Gen.int(in: 0...100)) { n in
     #expect(n + n == n * 2)
   }
 }
 ```
 Example with multiple inputs, and a custom repeat count:
 ```swift
 import Testing
-import Gen
 import PropertyBased
 
-let stringCreator = Gen.letterOrNumber.string(of: .int(in: 1...10))
+let stringCreator = Gen.letterOrNumber.string(of: Gen.int(in: 1...10))
 
 @Test func testStringRepeat() async {
-  await propertyCheck(count: 500, input: stringCreator, .int(in: 0...5)) { str, n in
+  await propertyCheck(count: 500, input: stringCreator, Gen.int(in: 0...5)) { str, n in
     let actual = String(repeating: str, count: n)
     #expect(actual.length == str.length * n)
   }
@@ -52,7 +51,7 @@ It's possible that a test only fails on very specific inputs that don't trigger
 
 ```swift
 @Test func failsSometimes() async {
-  await propertyCheck(input: .int(in: 0...1000)) { n in
+  await propertyCheck(input: Gen.int(in: 0...1000)) { n in
     #expect(n < 990)
   }
 }
@@ -70,19 +69,46 @@ You can supply the fixed seed to reproduce the issue every time.
 ```swift
 @Test(.fixedSeed("aKPPWDEafU0CGMDYHef/ETcbYUyjWQvRVP1DTNy6qJk="))
 func failsSometimes() async {
-  await propertyCheck(input: .int(in: 0...1000)) { n in
+  await propertyCheck(input: Gen.int(in: 0...1000)) { n in
     #expect(n < 990)
   }
 }
 ```
 
-# Limitations
+# Shrinking
 
-This library currently does not include shrinking functionality, which would allow for failing inputs to be reduced to simpler values (e.g. numbers closer to zero, or collections with fewer elements).
+> [!NOTE] 
+> This feature is experimental, and disabled by default. The shrinking output will be very verbose, due to a limitation in Swift Testing.
 
-1. The version of the Testing library that's bundled with Swift currently doesn't allow third-party plugins to change the behavior of issue reporting. Without changes, every intermediate step in the shrinking process will be reported as a new issue.
-2. Adding shrinker functions to `swift-gen` is possibly out of scope for that package. Since valid shrinker values depend on the specifications of the generator, a new fork of that project would be required in the future.
+When a failing case has been found, it's possible that the input is large and contrived, such as arrays with many elements. When _shrinking_ is enabled, PropertyBased will repeat a failing test until it finds the smallest possible input that still causes a failure.
+
+For example, the following test fails when the given numbers sum to a value above a certain threshold:
+
+```swift
+@Test func checkSumInRange() async {
+    await propertyCheck(input: Gen.int(in: 0...100).array(of: 1...10)) { numbers in
+        let sum = numbers.reduce(0, +)
+        #expect(sum < 250)
+    }
+}
+```
+
+The generator could come up with an array like `[63, 61, 33, 53, 97, 68, 23, 16]`, which sums to `414`. Ideally, we want to have an input that sums to exactly `250`.
+
+Enable the shrinker by adding the `shrinking` trait:
+
+```swift
+@Test(.shrinking) func checkSumInRange() async
+```
+
+After shrinking, the new failing case is `[46, 97, 68, 23, 16]`, which sums to exactly `250`. The first few elements have been removed, which the middle element has been reduced to be closer to the edge.
+
+When using the built-in generators and the `zip` function, shrinkers will also be composed.
 
 # License
 
-Copyright (c) 2025 Lennard Sprong. [MIT License](./LICENSE)
+Copyright (c) 2025 Lennard Sprong.
+
+Includes a modified version of [swift-gen](https://github.com/pointfreeco/swift-gen), which is Copyright (c) 2019 Point-Free, Inc.
+
+[MIT License](./LICENSE)

README.md

@@ -0,0 +1,23 @@
+//
+//  ClosedIntegerRange.swift
+//  PropertyBased
+//
+//  Created by Lennard Sprong on 13/05/2025.
+//
+
+extension ClosedRange where Bound: FixedWidthInteger {
+    /// Coerce any range to a ClosedRange.
+    ///
+    /// If the range doesn't have a lower or upper bound, `Bound.min` and `Bound.max` are used respectively.
+    @usableFromInline init(_ range: some RangeExpression<Bound>) {
+        if !range.contains(Bound.max) {
+            self = .init(range.relative(to: .min ..< .max))
+        } else if range.contains(Bound.min) {
+            self = .min ... .max
+        } else if range.contains(Bound.max - 1) {
+            self = range.relative(to: .min ..< .max).lowerBound ... .max
+        } else {
+            self = .max ... .max
+        }
+    }
+}

Sources/PropertyBased/ClosedIntegerRange.swift

@@ -0,0 +1,69 @@
+# ``PropertyBased/Gen``
+
+This namespace can be extended with custom generators, while hiding certain implementation details from call sites.
+
+For example, a new generator for a `Int256` type could be added like this:
+
+```swift
+extension Gen where Value == Int256 {
+    static func int256() -> Generator<Int256, Shrink.Integral<Int256>> {
+        Gen<Int256>.value()
+    }
+}
+```
+
+This new generator can now be used by writing the following: 
+```swift
+Gen.int256()
+```
+
+See ``Generator`` for transforming generators into collections and other values.
+
+## Topics
+
+### Generating numbers
+
+- ``/Gen/int(in:)``
+- ``/Gen/float(in:)``
+- ``/Gen/double(in:)``
+- ``/Gen/bool``
+
+### Generating strings
+
+You can generate individual characters, and use ``/Generator/string(of:)`` to form strings.
+
+- ``/Gen/letter``
+- ``/Gen/lowercaseLetter``
+- ``/Gen/uppercaseLetter``
+- ``/Gen/number``
+- ``/Gen/letterOrNumber``
+- ``/Gen/latin1``
+- ``/Gen/ascii``
+- ``/Gen/character(in:)``
+- ``/Gen/unicodeScalar(in:)``
+
+### Handling immutable collections
+
+- ``/Gen/case``
+- ``/Gen/element(of:)``
+- ``/Gen/shuffled(_:)``
+
+### Generating specific number types
+
+- ``/Gen/int8(in:)``
+- ``/Gen/int16(in:)``
+- ``/Gen/int32(in:)``
+- ``/Gen/int64(in:)``
+- ``/Gen/int128(in:)``
+- ``/Gen/uint(in:)``
+- ``/Gen/uint8(in:)``
+- ``/Gen/uint16(in:)``
+- ``/Gen/uint32(in:)``
+- ``/Gen/uint64(in:)``
+- ``/Gen/uint128(in:)``
+- ``/Gen/cgFloat(in:)``
+- ``/Gen/float16(in:)``
+
+## See Also
+
+- ``PropertyBased/Generator``

Sources/PropertyBased/Documentation.docc/Gen.md

@@ -0,0 +1,28 @@
+# ``PropertyBased/Generator``
+
+## Topics
+
+### Creating custom generators
+
+- ``init(run:)``
+- ``init(run:shrink:)``
+
+### Testing a generator
+
+- ``run(using:)``
+
+### Grouping generated values
+
+- ``pair``
+- ``string(of:)``
+- ``array(of:)``
+- ``set(ofAtMost:)``
+- ``dictionary(ofAtMost:)``
+
+### Transforming generators
+
+- ``map(_:)-9wz4v``
+- ``compactMap(_:)``
+- ``filter(_:)``
+- ``optional``
+- ``asResult(withFailure:successRate:)``

Sources/PropertyBased/Documentation.docc/Generator.md

@@ -0,0 +1,12 @@
+# ``PropertyBased``
+
+PropertyBased is a Swift 6 library that enables Property-Based Testing in `swift-testing`, similar to QuickCheck for Haskell or FsCheck for F# and C#.
+
+Property-Based Testing can be used as an alternative for (or in addition to) testing with hardcoded values. Run tests with random values, and easily switch to specific values when debugging a test failure. 
+
+## Topics
+
+### Getting started
+
+- ``propertyCheck(count:input:perform:isolation:sourceLocation:)``
+- ``Gen``