 	}
 }
 
-public struct Large<A : protocol<RandomType, LatticeType, IntegerType>> : Arbitrary {
-	public let getLarge : A
-
-	public init(_ lrg : A) {
-		self.getLarge = lrg
-	}
-
-	public var description : String {
-		return "Large( \(self.getLarge) )"
-	}
-
-	public static var arbitrary : Gen<Large<A>> {
-		return Gen<A>.choose((A.min, A.max)).fmap(Large.init)
-	}
-
-	public static func shrink(bl : Large<A>) -> [Large<A>] {
-		return bl.getLarge.shrinkIntegral.map(Large.init)
-	}
-}
-
-/// Guarantees that every generated integer is greater than 0.
-public struct Positive<A : protocol<Arbitrary, SignedNumberType>> : Arbitrary, CustomStringConvertible {
-	public let getPositive : A
-
-	public init(_ pos : A) {
-		self.getPositive = pos
-	}
-
-	public var description : String {
-		return "Positive( \(self.getPositive) )"
-	}
-
-	public static var arbitrary : Gen<Positive<A>> {
-		return A.arbitrary.fmap(Positive.init • abs).suchThat { $0.getPositive > 0 }
-	}
-
-	public static func shrink(bl : Positive<A>) -> [Positive<A>] {
-		return A.shrink(bl.getPositive).filter({ $0 > 0 }).map(Positive.init)
-	}
-}
-
-extension Positive : CoArbitrary {
-	// Take the lazy way out.
-	public static func coarbitrary<C>(x : Positive) -> (Gen<C> -> Gen<C>) {
-		return coarbitraryPrintable(x)
-	}
-}
-
-/// Guarantees that every generated integer is never 0.
-public struct NonZero<A : protocol<Arbitrary, IntegerType>> : Arbitrary, CustomStringConvertible {
-	public let getNonZero : A
-
-	public init(_ non : A) {
-		self.getNonZero = non
-	}
-
-	public var description : String {
-		return "NonZero( \(self.getNonZero) )"
-	}
-
-	public static var arbitrary : Gen<NonZero<A>> {
-		return NonZero.init <^> A.arbitrary.suchThat { $0 != 0 }
-	}
-
-	public static func shrink(bl : NonZero<A>) -> [NonZero<A>] {
-		return A.shrink(bl.getNonZero).filter({ $0 != 0 }).map(NonZero.init)
-	}
-}
-
-extension NonZero : CoArbitrary {
-	public static func coarbitrary<C>(x : NonZero) -> (Gen<C> -> Gen<C>) {
-		return x.getNonZero.coarbitraryIntegral()
-	}
-}
-
-/// Guarantees that every generated integer is greater than or equal to 0.
-public struct NonNegative<A : protocol<Arbitrary, IntegerType>> : Arbitrary, CustomStringConvertible {
-	public let getNonNegative : A
-
-	public init(_ non : A) {
-		self.getNonNegative = non
-	}
-
-	public var description : String {
-		return "NonNegative( \(self.getNonNegative) )"
-	}
-
-	public static var arbitrary : Gen<NonNegative<A>> {
-		return NonNegative.init <^> A.arbitrary.suchThat { $0 >= 0 }
-	}
-
-	public static func shrink(bl : NonNegative<A>) -> [NonNegative<A>] {
-		return A.shrink(bl.getNonNegative).filter({ $0 >= 0 }).map(NonNegative.init)
-	}
-}
-
-extension NonNegative : CoArbitrary {
-	public static func coarbitrary<C>(x : NonNegative) -> (Gen<C> -> Gen<C>) {
-		return x.getNonNegative.coarbitraryIntegral()
-	}
-}
-
-private func undefined<A>() -> A {
-	fatalError("")
-}
-

	}
}

extension ArrowOf : CustomReflectable {
	public func customMirror() -> Mirror {
		return Mirror(self, children: [
			"types": "\(T.self) -> \(U.self)",
			"currentMap": self.table,

	}
}

private final class IsoOfImpl<T : protocol<Hashable, CoArbitrary, Arbitrary>, U : protocol<Equatable, CoArbitrary, Arbitrary>> : Arbitrary, CustomStringConvertible {
	var table : Dictionary<T, U>
	var embed : T -> U
	var project : U -> T

	init (_ table : Dictionary<T, U>, _ embed : (T -> U), _ project : (U -> T)) {
		self.table = table
		self.embed = embed
		self.project = project
	}

	convenience init(_ embed : (T -> U), _ project : (U -> T)) {
		self.init(Dictionary(), { (_ : T) -> U in return undefined() }, { (_ : U) -> T in return undefined() })

		self.embed = { [weak self] t in
