 }
 
 /// Generates a Swift function from T to U.
-public final class ArrowOf<T : protocol<Hashable, CoArbitrary>, U : Arbitrary> : Arbitrary, CustomStringConvertible {
+public struct ArrowOf<T : protocol<Hashable, CoArbitrary>, U : Arbitrary> : Arbitrary, CustomStringConvertible {
+	private let _impl : ArrowOfImpl<T, U>
+
+	public var getArrow : T -> U {
+		return self._impl.arr
+	}
+
+	public var description : String {
+		return self._impl.description
+	}
+
+	public static var arbitrary : Gen<ArrowOf<T, U>> {
+		return ArrowOfImpl<T, U>.arbitrary.fmap(ArrowOf.init)
+	}
+}
+
+/// Generates two isomorphic Swift function from T to U and back again.
+public struct IsoOf<T : protocol<Hashable, CoArbitrary, Arbitrary>, U : protocol<Equatable, CoArbitrary, Arbitrary>> : Arbitrary, CustomStringConvertible {
+	private let _impl : IsoOfImpl<T, U>
+
+	public var getTo : T -> U {
+		return self._impl.embed
+	}
+
+	public var getFrom : U -> T {
+		return self._impl.project
+	}
+
+	public var description : String {
+		return self._impl.description
+	}
+
+	public static var arbitrary : Gen<IsoOf<T, U>> {
+		return IsoOfImpl<T, U>.arbitrary.fmap(IsoOf.init)
+	}
+}
+
+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()
+	}
+}
+
+/// Implementation Details
+
+private func undefined<A>() -> A {
+	fatalError("")
+}
+
+private final class ArrowOfImpl<T : protocol<Hashable, CoArbitrary>, U : Arbitrary> : Arbitrary, CustomStringConvertible {
 	private var table : Dictionary<T, U>
 	private var arr : T -> U
-	public var getArrow : T -> U {
-		return self.arr
-	}
-
-	private init (_ table : Dictionary<T, U>, _ arr : (T -> U)) {
+
+	init (_ table : Dictionary<T, U>, _ arr : (T -> U)) {
 		self.table = table
 		self.arr = arr
 	}
 
-	public convenience init(_ arr : (T -> U)) {
+	convenience init(_ arr : (T -> U)) {
 		self.init(Dictionary(), { (_ : T) -> U in return undefined() })
 
 		self.arr = { [weak self] x in

	}
}

/// Generates two isomorphic Swift function from T to U and back again.
public final class IsoOf<T : protocol<Hashable, CoArbitrary, Arbitrary>, U : protocol<Equatable, CoArbitrary, Arbitrary>> : Arbitrary, CustomStringConvertible {
	private var table : Dictionary<T, U>
	private var embed : T -> U
	private var project : U -> T

	public var getTo : T -> U {
		return embed
	}

	public var getFrom : U -> T {
		return project
	}

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

	public 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

	}
}

