 	}
 }
 
+let composedArbitraryLargeFoo = Gen<ArbitraryLargeFoo>.compose { c in
+    let evenInt16 = Int16.arbitrary.suchThat { $0 % 2 == 0 }
+    return ArbitraryLargeFoo(
+        a: c.generate(),
+        b: c.generate(evenInt16),
+        c: c.generate(),
+        d: c.generate(),
+        e: c.generate(),
+        f: c.generate(),
+        g: c.generate(),
+        h: c.generate(),
+        i: c.generate(),
+        j: c.generate(),
+        k: c.generate(),
+        l: (c.generate(), c.generate()),
+        m: (c.generate(), c.generate(), c.generate()),
+        n: (c.generate(), c.generate(), c.generate(), c.generate())
+    )
+}
+
 class SimpleSpec : XCTestCase {
 	func testAll() {
 		property("Integer Equality is Reflexive") <- forAll { (i : Int8) in

			}
		}
        
        let composedArbitraryLargeFoo = Gen<ArbitraryLargeFoo>.compose { c in
            return ArbitraryLargeFoo(
                a: c.generate(),
                b: c.generate(),
                c: c.generate(),
                d: c.generate(),
                e: c.generate(),
                f: c.generate(),
                g: c.generate(),
                h: c.generate(),
                i: c.generate(),
                j: c.generate(),
                k: c.generate(),
                l: (c.generate(), c.generate()),
                m: (c.generate(), c.generate(), c.generate()),
                n: (c.generate(), c.generate(), c.generate(), c.generate())
            )   
        }
        
        property("composition generates high-entropy, arbitrary values")
        <- forAll(composedArbitraryLargeFoo, composedArbitraryLargeFoo) { a, b in
            return a != b
        }
	}
}


	public static var arbitrary : Gen<ArbitraryFoo> {
		return Gen<(Int, Int)>.zip(Int.arbitrary, Int.arbitrary).map(ArbitraryFoo.init)
	}
}

public struct ArbitraryMutableFoo : Arbitrary {
    var a: Int8
    var b: Int16
    
    public init() {
        a = 0
        b = 0
    }
    
    public static var arbitrary: Gen<ArbitraryMutableFoo> {
        return Gen.compose { c in
            var foo = ArbitraryMutableFoo()
            foo.a = c.generate()
            foo.b = c.generate()
            return foo
        }
    }
}

extension ArbitraryMutableFoo: Equatable {}

public func == (lhs: ArbitraryMutableFoo, rhs: ArbitraryMutableFoo) -> Bool {
    return lhs.a == rhs.a && lhs.b == rhs.b
}

public struct ArbitraryLargeFoo {
