Merge pull request #298 from CodaFi/into-the-wild-blue-yonder

CodaFi · CodaFi · commit 78665a092185 · 2016-03-23T19:59:10.000-04:00
Update to Swift 2.2
diff --git a/.travis.yml b/.travis.yml
@@ -1,13 +1,13 @@
 language: objective-c
-osx_image: xcode7.2
+osx_image: xcode7.3
 env:
     - TEST_CONFIG="RELEASE"
     - TEST_CONFIG="PODS"
 
 before_install: true
 install: true
 script: 
-    - if [[ "$TEST_CONFIG" == "RELEASE" ]]; then script/cibuild Swiftz Swiftz-iOS ; fi
+    - if [[ "$TEST_CONFIG" == "RELEASE" ]]; then script/cibuild Swiftz ; fi
     - if [[ "$TEST_CONFIG" == "RELEASE" ]]; then xcodebuild test -scheme Swiftz-tvOS -destination 'platform=tvOS Simulator,name=Apple TV 1080p' ; fi
     - if [[ "$TEST_CONFIG" == "RELEASE" ]]; then xcodebuild build -scheme Swiftz-watchOS -destination 'platform=watchOS Simulator,name=Apple Watch - 42mm' ; fi
     - if [[ "$TEST_CONFIG" == "PODS" ]]; then pod lib lint; fi
diff --git a/Cartfile.resolved b/Cartfile.resolved
@@ -1,3 +1,3 @@
-github "typelift/Operadics" "e21d7edbe02c7e34ae6a33ba59d278b613b2ce44"
-github "typelift/SwiftCheck" "v0.4.4"
-github "typelift/Swiftx" "v0.3.2"
+github "typelift/Operadics" "8117a84bb4111814c35af80285f3f9baff290d7e"
+github "typelift/SwiftCheck" "v0.6.0"
+github "typelift/Swiftx" "v0.4.0"
diff --git a/Carthage/Checkouts/Operadics b/Carthage/Checkouts/Operadics
@@ -1 +1 @@
-Subproject commit e21d7edbe02c7e34ae6a33ba59d278b613b2ce44
+Subproject commit 8117a84bb4111814c35af80285f3f9baff290d7e
diff --git a/Carthage/Checkouts/SwiftCheck b/Carthage/Checkouts/SwiftCheck
@@ -1 +1 @@
-Subproject commit 118d47429bef32296e2f663ae72d8aa24d4c9a66
+Subproject commit f2141461f015315cc583222f0bb30ae07da8aad8
diff --git a/Carthage/Checkouts/Swiftx b/Carthage/Checkouts/Swiftx
@@ -1 +1 @@
-Subproject commit baeda0db436708521bd3fc5d8c81b29c9dbe3b63
+Subproject commit 95b897833340206b5c2f531a22dd5ab235c1194c
diff --git a/Swiftz.podspec b/Swiftz.podspec
@@ -12,5 +12,5 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = "9.1"
   s.watchos.deployment_target = "2.1"  
   s.source   = { :git => "https://github.com/typelift/Swiftz.git", :tag => "v#{s.version}", :submodules => true }
-  s.source_files = "Swiftz/*.swift", "**/Swiftx/*.swift", "Carthage/Checkouts/Operadics/*.swift"
+  s.source_files = "Swiftz/*.swift", "**/Swiftx/*.swift", "Carthage/Checkouts/Operadics/Operators.swift"
 end
diff --git a/Swiftz/Applicative.swift b/Swiftz/Applicative.swift
@@ -13,18 +13,18 @@
 /// needing to unwrap or map over their contents.
 public protocol Applicative : Pointed, Functor {
 	/// Type of Functors containing morphisms from our objects to a target.
-	typealias FAB = K1<A -> B>
+	associatedtype FAB = K1<A -> B>
 
 	/// Applies the function encapsulated by the Functor to the value encapsulated by the receiver.
 	func ap(f : FAB) -> FB
 }
 
 /// Additional functions to be implemented by those types conforming to the Applicative protocol.
 public protocol ApplicativeOps : Applicative {
-	typealias C
-	typealias FC = K1<C>
-	typealias D
-	typealias FD = K1<D>
+	associatedtype C
+	associatedtype FC = K1<C>
+	associatedtype D
+	associatedtype FD = K1<D>
 
 	/// Lift a function to a Functorial action.
 	static func liftA(f : A -> B) -> Self -> FB
diff --git a/Swiftz/Arrow.swift b/Swiftz/Arrow.swift
@@ -44,25 +44,25 @@
 /// Arrows inherit from Category so we can get Composition For Free™.
 public protocol Arrow : Category {
 	/// Some arbitrary target our arrow can compose with.
-	typealias D
+	associatedtype D
 	/// Some arbitrary target our arrow can compose with.
-	typealias E
+	associatedtype E
 
 	/// Type of the result of first().
-	typealias FIRST = K2<(A, D), (B, D)>
+	associatedtype FIRST = K2<(A, D), (B, D)>
 	/// Type of the result of second().
-	typealias SECOND = K2<(D, A), (D, B)>
+	associatedtype SECOND = K2<(D, A), (D, B)>
 
 	/// Some arrow with an arbitrary target and source.  Used in split().
-	typealias ADE = K2<D, E>
+	associatedtype ADE = K2<D, E>
 	/// Type of the result of ***.
-	typealias SPLIT = K2<(A, D), (B, E)>
+	associatedtype SPLIT = K2<(A, D), (B, E)>
 
 	/// Some arrow from our target to some other arbitrary target.  Used in fanout().
-	typealias ABD = K2<A, D>
+	associatedtype ABD = K2<A, D>
 
 	/// Type of the result of &&&.
-	typealias FANOUT = K2<B, (B, D)>
+	associatedtype FANOUT = K2<B, (B, D)>
 
 	/// Lift a function to an arrow.
 	static func arr(_ : A -> B) -> Self
@@ -92,7 +92,7 @@ public protocol Arrow : Category {
 /// Arrows that can produce an identity arrow.
 public protocol ArrowZero : Arrow {
 	/// An arrow from A -> B.  Colloquially, the "zero arrow".
-	typealias ABC = K2<A, B>
+	associatedtype ABC = K2<A, B>
 
 	/// The identity arrow.
 	static func zeroArrow() -> ABC
@@ -132,17 +132,17 @@ public protocol ArrowPlus : ArrowZero {
 ///
 public protocol ArrowChoice : Arrow {
 	/// The result of left
-	typealias LEFT = K2<Either<A, D>, Either<B, D>>
+	associatedtype LEFT = K2<Either<A, D>, Either<B, D>>
 	/// The result of right
-	typealias RIGHT = K2<Either<D, A>, Either<D, B>>
+	associatedtype RIGHT = K2<Either<D, A>, Either<D, B>>
 
 	/// The result of +++
-	typealias SPLAT = K2<Either<A, D>, Either<B, E>>
+	associatedtype SPLAT = K2<Either<A, D>, Either<B, E>>
 
 	/// Some arrow from a different source and target for fanin.
-	typealias ACD = K2<B, D>
+	associatedtype ACD = K2<B, D>
 	/// The result of |||
-	typealias FANIN = K2<Either<A, B>, D>
+	associatedtype FANIN = K2<Either<A, B>, D>
 
 	/// Feed marked inputs through the argument arrow, passing the rest through unchanged to the
 	/// output.
@@ -169,7 +169,7 @@ public protocol ArrowChoice : Arrow {
 ///          a -------> a - •
 ///
 public protocol ArrowApply : Arrow {
-	typealias APP = K2<(Self, A), B>
+	associatedtype APP = K2<(Self, A), B>
 	static func app() -> APP
 }
 
@@ -185,7 +185,7 @@ public protocol ArrowApply : Arrow {
 ///           d-------•
 ///
 public protocol ArrowLoop : Arrow {
-	typealias LOOP = K2<(A, D), (B, D)>
+	associatedtype LOOP = K2<(A, D), (B, D)>
 
 	static func loop(_ : LOOP) -> Self
 }
diff --git a/Swiftz/Bifunctor.swift b/Swiftz/Bifunctor.swift
@@ -11,14 +11,14 @@
 /// FIXME: Something in swiftc doesn't like it when conforming instances use a generic <D> in
 /// definitions of rightMap.  It has been removed in all instances for now.
 public protocol Bifunctor {
-	typealias L
-	typealias B
-	typealias R
-	typealias D
-	typealias PAC = K2<L, R>
-	typealias PAD = K2<L, D>
-	typealias PBC = K2<B, R>
-	typealias PBD = K2<B, D>
+	associatedtype L
+	associatedtype B
+	associatedtype R
+	associatedtype D
+	associatedtype PAC = K2<L, R>
+	associatedtype PAD = K2<L, D>
+	associatedtype PBC = K2<B, R>
+	associatedtype PBD = K2<B, D>
 
 	/// Map two functions individually over both sides of the bifunctor at the same time.
 	func bimap(f : L -> B, _ g : R -> D) -> PBD
diff --git a/Swiftz/Category.swift b/Swiftz/Category.swift
@@ -16,18 +16,18 @@
 /// function is also called >>>.
 public protocol Category {
 	/// Source
-	typealias A
+	associatedtype A
 	/// Target
-	typealias B
+	associatedtype B
 	/// Other Target; Usually Any.
-	typealias C
+	associatedtype C
 
 	/// The identity category
-	typealias CAA = K2<A, A>
+	associatedtype CAA = K2<A, A>
 	/// A Category we can compose with.
-	typealias CBC = K2<B, C>
+	associatedtype CBC = K2<B, C>
 	/// The composition of this Category with the Category above.
-	typealias CAC = K2<A, C>
+	associatedtype CAC = K2<A, C>
 
 	/// The identity morphism.
 	static func id() -> CAA
diff --git a/Swiftz/Comonad.swift b/Swiftz/Comonad.swift
@@ -10,7 +10,7 @@
 ///
 /// "A comonoid in the monoidal category of endofunctors"
 public protocol Comonad : Copointed, Functor {
-	typealias FFA = K1<Self>
+	associatedtype FFA = K1<Self>
 
 	/// Duplicates the surrounding comonadic context and embeds the receiver in it.
 	func duplicate() -> FFA
diff --git a/Swiftz/Copointed.swift b/Swiftz/Copointed.swift
@@ -8,6 +8,6 @@
 
 /// Functors equipped with a copoint that yields a value.
 public protocol Copointed {
-	typealias A
+	associatedtype A
 	func extract() -> A
 }
diff --git a/Swiftz/Foldable.swift b/Swiftz/Foldable.swift
@@ -8,8 +8,8 @@
 
 /// A `Foldable` type admits a way of "summarizing" its entire structure.
 public protocol Foldable {
-	typealias A
-	typealias B
+	associatedtype A
+	associatedtype B
 
 	/// Summarizes the receiver right-associatively.
 	func foldr(folder : A -> B -> B, _ initial : B) -> B
diff --git a/Swiftz/Functor.swift b/Swiftz/Functor.swift
@@ -10,11 +10,11 @@
 /// in another set.
 public protocol Functor {
 	/// Source
-	typealias A
+	associatedtype A
 	/// Target
-	typealias B
+	associatedtype B
 	/// A Target Functor
-	typealias FB = K1<B>
+	associatedtype FB = K1<B>
 
 	/// Map a function over the value encapsulated by the Functor.
 	func fmap(f : A -> B) -> FB
diff --git a/Swiftz/HList.swift b/Swiftz/HList.swift
@@ -14,8 +14,8 @@
 /// element, and compatible operations on said elements exist fully at compile time.  HLists, like
 /// regular lists, support folds, maps, and appends, only at the type rather than term level.
 public protocol HList {
-	typealias Head
-	typealias Tail
+	associatedtype Head
+	associatedtype Tail
 
 	static var isNil : Bool { get }
 	static var length : Int { get }
diff --git a/Swiftz/List.swift b/Swiftz/List.swift
@@ -395,7 +395,7 @@ public struct List<Element> {
 	///
 	/// For infinite lists this function will diverge.
 	public func reverse() -> List<Element> {
-		return self.reduce(flip(List.cons), initial: [])
+		return self.reduce(flip(curry(List.cons)), initial: [])
 	}
 
 	/// Given a predicate, searches the list until it find the first match, and returns that,
diff --git a/Swiftz/Monad.swift b/Swiftz/Monad.swift
@@ -14,10 +14,10 @@ public protocol Monad : Applicative {
 }
 
 public protocol MonadOps : Monad {
-	typealias C
-	typealias FC = K1<C>
-	typealias D
-	typealias FD = K1<D>
+	associatedtype C
+	associatedtype FC = K1<C>
+	associatedtype D
+	associatedtype FD = K1<D>
 
 	/// Lift a function to a Monadic action.
 	static func liftM(f : A -> B) -> Self -> FB
@@ -35,12 +35,12 @@ public protocol MonadOps : Monad {
 /// Monads that allow zipping.
 public protocol MonadZip : Monad {
 	/// An arbitrary domain.  Usually Any.
-	typealias C
+	associatedtype C
 	/// A monad with an arbitrary domain.
-	typealias FC = K1<C>
+	associatedtype FC = K1<C>
 
 	/// A Monad containing a zipped tuple.
-	typealias FTAB = K1<(A, B)>
+	associatedtype FTAB = K1<(A, B)>
 
 	/// Zip for monads.
 	func mzip(_ : FB) -> FTAB
diff --git a/Swiftz/Pointed.swift b/Swiftz/Pointed.swift
@@ -8,6 +8,6 @@
 
 /// Functors equipped with a point taking values to instances of themselves.
 public protocol Pointed {
-	typealias A
+	associatedtype A
 	static func pure(_ : A) -> Self
 }
diff --git a/Swiftz/StringExt.swift b/Swiftz/StringExt.swift
@@ -57,7 +57,7 @@ extension String {
 
 	/// Returns a string containing the characters of the receiver in reverse order.
 	public func reverse() -> String {
-		return self.reduce(flip(String.cons), initial: "")
+		return self.reduce(flip(curry(String.cons)), initial: "")
 	}
 
 	/// Maps a function over the characters of a string and returns a new string of those values.
diff --git a/Swiftz/TupleExt.swift b/Swiftz/TupleExt.swift
@@ -26,55 +26,3 @@ public func ==(lhs: (), rhs: ()) -> Bool {
 }
 
 public func !=(lhs: (), rhs: ()) -> Bool { return false }
-
-// Unlike Python a 1-tuple is just it's contained element.
-
-public func == <T:Equatable,U:Equatable>(lhs: (T,U), rhs: (T,U)) -> Bool {
-	let (l0,l1) = lhs
-	let (r0,r1) = rhs
-	return l0 == r0 && l1 == r1
-}
-
-public func != <T:Equatable,U:Equatable>(lhs: (T,U), rhs: (T,U)) -> Bool {
-	return !(lhs==rhs)
-}
-
-public func == <T:Equatable,U:Equatable,V:Equatable>(lhs: (T,U,V), rhs: (T,U,V)) -> Bool {
-	let (l0,l1,l2) = lhs
-	let (r0,r1,r2) = rhs
-	return l0 == r0 && l1 == r1 && l2 == r2
-}
-
-public func != <T:Equatable,U:Equatable,V:Equatable>(lhs: (T,U,V), rhs: (T,U,V)) -> Bool {
-	return !(lhs==rhs)
-}
-
-public func == <T:Equatable,U:Equatable,V:Equatable,W:Equatable>(lhs: (T,U,V,W), rhs: (T,U,V,W)) -> Bool {
-	let (l0,l1,l2,l3) = lhs
-	let (r0,r1,r2,r3) = rhs
-	return l0 == r0 && l1 == r1 && l2 == r2 && l3 == r3
-}
-
-public func != <T:Equatable,U:Equatable,V:Equatable,W:Equatable>(lhs: (T,U,V,W), rhs: (T,U,V,W)) -> Bool {
-	return !(lhs==rhs)
-}
-
-public func == <T:Equatable,U:Equatable,V:Equatable,W:Equatable,X:Equatable>(lhs: (T,U,V,W,X), rhs: (T,U,V,W,X)) -> Bool {
-	let (l0,l1,l2,l3,l4) = lhs
-	let (r0,r1,r2,r3,r4) = rhs
-	return l0 == r0 && l1 == r1 && l2 == r2 && l3 == r3 && l4 == r4
-}
-
-public func != <T:Equatable,U:Equatable,V:Equatable,W:Equatable,X:Equatable>(lhs: (T,U,V,W,X), rhs: (T,U,V,W,X)) -> Bool {
-	return !(lhs==rhs)
-}
-
-public func == <T:Equatable,U:Equatable,V:Equatable,W:Equatable,X:Equatable,Z:Equatable>(lhs: (T,U,V,W,X,Z), rhs: (T,U,V,W,X,Z)) -> Bool {
-	let (l0,l1,l2,l3,l4,l5) = lhs
-	let (r0,r1,r2,r3,r4,r5) = rhs
-	return l0 == r0 && l1 == r1 && l2 == r2 && l3 == r3 && l4 == r4 && l5 == r5
-}
-
-public func != <T:Equatable,U:Equatable,V:Equatable,W:Equatable,X:Equatable,Z:Equatable>(lhs: (T,U,V,W,X,Z), rhs: (T,U,V,W,X,Z)) -> Bool {
-	return !(lhs==rhs)
-}
diff --git a/Swiftz/Writer.swift b/Swiftz/Writer.swift
@@ -20,7 +20,8 @@ public struct Writer<W : Monoid, T> {
 
 	/// Returns a `Writer` that applies the function to its current value and environment.
 	public func mapWriter<U, V : Monoid>(f : (T, W) -> (U, V)) -> Writer<V, U> {
-		return Writer<V, U>(f(self.runWriter))
+		let (t, w) = self.runWriter
+		return Writer<V, U>(f(t, w))
 	}
 
 	/// Extracts the current environment from the receiver.
diff --git a/SwiftzTests/IdentitySpec.swift b/SwiftzTests/IdentitySpec.swift
@@ -19,7 +19,7 @@ extension Identity where T : Arbitrary {
 extension Identity : WitnessedArbitrary {
 	public typealias Param = T
 
-	public static func forAllWitnessed<A : Arbitrary>(wit : A -> T)(pf : (Identity<T> -> Testable)) -> Property {
+	public static func forAllWitnessed<A : Arbitrary>(wit : A -> T, pf : (Identity<T> -> Testable)) -> Property {
 		return forAllShrink(Identity<A>.arbitrary, shrinker: const([]), f: { bl in
 			return pf(bl.fmap(wit))
 		})
diff --git a/SwiftzTests/ListSpec.swift b/SwiftzTests/ListSpec.swift
@@ -24,7 +24,7 @@ extension List where Element : Arbitrary {
 extension List : WitnessedArbitrary {
 	public typealias Param = Element
 
-	public static func forAllWitnessed<A : Arbitrary>(wit : A -> Element)(pf : (List<Element> -> Testable)) -> Property {
+	public static func forAllWitnessed<A : Arbitrary>(wit : A -> Element, pf : (List<Element> -> Testable)) -> Property {
 		return forAllShrink(List<A>.arbitrary, shrinker: List<A>.shrink, f: { bl in
 			return pf(bl.map(wit))
 		})
diff --git a/SwiftzTests/NonEmptyListSpec.swift b/SwiftzTests/NonEmptyListSpec.swift
diff --git a/SwiftzTests/WriterSpec.swift b/SwiftzTests/WriterSpec.swift
