Removes operator, starts updating README, MIGRATING and CHANGELOG

Author: vittoriom

CHANGELOG.md

@@ -3,8 +3,11 @@
 ## 0.9
 
 **Breaking changes**
-- Swift 2.3 support
-- `batchGetAll` has been deprecated and replaced with a reified `allBatch` (see **New features**)
+- Swift 3.0 support (for Swift 2.3 use specific commit `5d354c829d766568f164c386c59de21357b5ccff` instead)
+- `batchGetAll` has been removed and replaced with a reified `allBatch` (see **New features**)
+- All deprecated functions have been removed
+- All custom operators have been removed in favor of their function counterparts
+- macOS and tvOS support has been temporarily dropped and will be probably re-added in the future 
 - `set` method on `CacheLevel` now returns a `Future` enabling error-handling and progress-tracking of `set` calls.
 
 **New Features**

Carlos/CacheProvider+iOS.swift

@@ -9,6 +9,12 @@ extension CacheProvider {
   - returns: An initialized and configured CacheLevel that takes NSURL keys and stores UIImage values. Network requests are pooled for efficiency. Keep in mind that calling this method twice returns two different instances. You should take care of retaining the result or use `sharedImageCache` instead
   */
   public static func imageCache() -> BasicCache<URL, UIImage> {
-    return MemoryCacheLevel<URL, UIImage>() >>> DiskCacheLevel<URL, UIImage>() >>> (NetworkFetcher().pooled() =>> ImageTransformer())
+    return MemoryCacheLevel<URL, UIImage>()
+      .compose(DiskCacheLevel<URL, UIImage>())
+      .compose(
+        NetworkFetcher()
+          .pooled()
+          .transformValues(ImageTransformer())
+      )
   }
 }

Carlos/CacheProvider.swift

@@ -14,13 +14,17 @@ public final class CacheProvider {
   - returns: An initialized and configured CacheLevel that takes NSURL keys and stores NSData values. Network requests are pooled for efficiency. Keep in mind that calling this method twice returns two different instances. You should take care of retaining the result or use `sharedDataCache` instead
   */
   public static func dataCache() -> BasicCache<URL, NSData> {
-    return MemoryCacheLevel<URL, NSData>() >>> (DiskCacheLevel<URL, NSData>() >>> NetworkFetcher()).pooled()
+    return MemoryCacheLevel<URL, NSData>()
+      .compose(
+        DiskCacheLevel<URL, NSData>().compose(NetworkFetcher())
+          .pooled()
+      )
   }
 
   /**
   - returns: An initialized and configured CacheLevel that takes NSURL keys and stores JSON values in the form of AnyObject. Network requests are pooled for efficiency. Keep in mind that calling this method twice returns two different instances. You should take care of retaining the result or use `sharedJSONCache` instead
   */
   public static func JSONCache() -> BasicCache<URL, AnyObject> {
-    return dataCache() =>> JSONTransformer()
+    return dataCache().transformValues(JSONTransformer())
   }
 }

Carlos/Carlos.swift

@@ -14,8 +14,6 @@ internal func wrapClosureIntoOneWayTransformer<A, B>(_ transformerClosure: @esca
   return OneWayTransformationBox(transform: transformerClosure)
 }
 
-infix operator =>>: MultiplicationPrecedence
-
 /// An abstraction for a generic cache level
 public protocol CacheLevel {
   /// A typealias for the key the cache level accepts

Carlos/Composed.swift

@@ -1,8 +1,6 @@
 import Foundation
 import PiedPiper
 
-infix operator >>>: AdditionPrecedence
-
 extension CacheLevel {
 
   /**
@@ -46,15 +44,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
-Composes two cache levels
-
-- parameter firstCache: The first cache level
-- parameter secondCache: The second cache level
-
-- returns: A new cache level that is the result of the composition of the two cache levels
-*/
-public func >>><A: CacheLevel, B: CacheLevel>(firstCache: A, secondCache: B) -> BasicCache<A.KeyType, A.OutputType> where A.KeyType == B.KeyType, A.OutputType == B.OutputType {
-  return firstCache.compose(secondCache)
-}

Carlos/ComposedOneWayTransformer.swift

@@ -13,15 +13,3 @@ extension OneWayTransformer {
     return OneWayTransformationBox(transform: self.transform >>> transformer.transform)
   }
 }
-
-/**
-Composes two OneWayTransformers
-
-- parameter firstTransformer: The first transformer to apply
-- parameter secondTransformer: The second transformer to apply
-
-- returns: A new OneWayTransformer that is the result of the composition of the two OneWayTransformers
-*/
-public func >>><A: OneWayTransformer, B: OneWayTransformer>(firstTransformer: A, secondTransformer: B) -> OneWayTransformationBox<A.TypeIn, B.TypeOut> where B.TypeIn == A.TypeOut {
-  return firstTransformer.compose(secondTransformer)
-}

Carlos/ComposedTwoWayTransformer.swift

@@ -16,15 +16,3 @@ extension TwoWayTransformer {
     )
   }
 }
-
-/**
-Composes two TwoWayTransformers
-
-- parameter firstTransformer: The first TwoWayTransformer to apply
-- parameter secondTransformer: The second TwoWayTransformer to apply
-
-- returns: A new TwoWayTransformer that is the result of the composition of the two TwoWayTransformers
-*/
-public func >>><A: TwoWayTransformer, B: TwoWayTransformer>(firstTransformer: A, secondTransformer: B) -> TwoWayTransformationBox<A.TypeIn, B.TypeOut> where B.TypeIn == A.TypeOut {
-  return firstTransformer.compose(secondTransformer)
-}

Carlos/Conditioned.swift

@@ -1,8 +1,6 @@
 import Foundation
 import PiedPiper
 
-infix operator <?>: MultiplicationPrecedence
-
 extension CacheLevel {
 
   /**
@@ -65,17 +63,3 @@ extension TwoWayTransformer {
     )
   }
 }
-
-/**
-Wraps a CacheLevel with a boolean condition on the key that controls when a get call should fail unconditionally
-
-- parameter condition: The condition closure that takes a key and returns true if the key can be fetched, or false if the request should fail unconditionally. The closure can also pass a specific error in case it wants to explicitly communicate why it failed. The condition can be asynchronous and has to return a Future<Bool>
-- parameter cache: The cache level you want to decorate
-
-- returns: A new BasicCache that will check for the condition before every get is dispatched to the decorated cache level
-
-The condition doesn't apply to the set, clear, onMemoryWarning calls
-*/
-public func <?><A: CacheLevel>(condition: @escaping (A.KeyType) -> Future<Bool>, cache: A) -> BasicCache<A.KeyType, A.OutputType> {
-  return cache.conditioned(condition)
-}

Carlos/ConditionedOutputProcessing.swift

@@ -1,8 +1,6 @@
 import Foundation
 import PiedPiper
 
-infix operator ?>>: MultiplicationPrecedence
-
 extension Future {
 
   /**
@@ -43,33 +41,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
- Adds a conditioned post-processing step to the results of a fetch closure
- 
- As usual, if the transformation fails, the fetch will also fail
- 
- - parameter fetchClosure: The closure that will take care of fetching the values
- - parameter conditionedTransformer: The transformer that will be applied to every successful fetch. The transformer gets the key used for the request (where it can apply its condition on) and the fetched value, and has to return the same type of the value.
-   The transformation won't be applied when setting values on the cache level, also considering fetch closures don't have a set operation.
- 
- - returns: A CacheLevel that incorporates the post-processing step after the fetch
- */
-public func ?>><A, B, T: ConditionedOneWayTransformer>(fetchClosure: @escaping (_ key: A) -> Future<B>, conditionedTransformer: T) -> BasicCache<A, B> where T.KeyType == A, T.TypeIn == B, T.TypeOut == B {
-  return wrapClosureIntoFetcher(fetchClosure).conditionedPostProcess(conditionedTransformer)
-}
-
-/**
- Adds a conditioned post-processing step to the get results of a given CacheLevel
- 
- As usual, if the transformation fails, the get request will also fail
- 
- - parameter cache: The CacheLevel you want to apply the post-processing step to
- - parameter conditionedTransformer: The transformer that will be applied to every successful fetch. The transformer gets the key used for the request (where it can apply its condition on) and the fetched value, and has to return the same type of the value.
- The transformation won't be applied when setting values on the cache level, also considering fetch closures don't have a set operation.
- 
- - returns: A transformed CacheLevel that incorporates the post-processing step
- */
-public func ?>><A: CacheLevel, T: ConditionedOneWayTransformer>(cache: A, conditionedTransformer: T) -> BasicCache<A.KeyType, A.OutputType> where T.KeyType == A.KeyType, T.TypeIn == A.OutputType, T.TypeOut == A.OutputType {
-  return cache.conditionedPostProcess(conditionedTransformer)
-}

Carlos/ConditionedValueTransformation.swift

@@ -48,16 +48,3 @@ extension CacheLevel {
   }
 }
 
-/**
- Adds a conditioned value transformation step to a given CacheLevel
- 
- As usual, if the transformation fails, the get (or set) request will also fail
- 
- - parameter cache: The CacheLevel you want to apply the value transformation step to
- - parameter conditionedTransformer: The transformer that will be applied to every get or set. The transformer gets the key used for the request (where it can apply its condition on) and the fetched value or the value to set, and returns a future with the transformed value.
- 
- - returns: A transformed CacheLevel that incorporates the value transformation step
- */
-public func ?>><A: CacheLevel, T: ConditionedTwoWayTransformer>(cache: A, conditionedTransformer: T) -> BasicCache<A.KeyType, T.TypeOut> where T.KeyType == A.KeyType, T.TypeIn == A.OutputType {
-  return cache.conditionedValueTransformation(transformer: conditionedTransformer)
-}

Carlos/Dispatched.swift

@@ -1,8 +1,6 @@
 import Foundation
 import PiedPiper
 
-infix operator ~>>
-
 extension CacheLevel {
   /**
   Dispatches all the operations of this CacheLevel on the given GCD queue
@@ -42,15 +40,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
-Dispatches all the operations of a given CacheLevel on the given GCD queue
- 
-- parameter lhs: The CacheLevel you want to dispatch on the given GCD queue
-- parameter rhs: The queue you want to dispatch all the operations (get, set, clear, onMemoryWarning) of the CacheLevel on
- 
-- returns: A new CacheLevel that dispatches all the operations on the given GCD queue
-*/
-public func ~>><A: CacheLevel>(lhs: A, rhs: DispatchQueue) -> BasicCache<A.KeyType, A.OutputType> {
-  return lhs.dispatch(rhs)
-}

Carlos/FetcherValueTransformation.swift

@@ -20,17 +20,3 @@ extension Fetcher {
     )
   }
 }
-
-/**
- Applies a transformation to a fetcher
- The transformation works by changing the type of the value the fetcher returns when succeeding
- Use this transformation when you store a value type but want to mount the fetcher in a pipeline that works with other value types
- 
- - parameter fetcher: The fetcher you want to transform
- - parameter transformer: The transformation you want to apply
- 
- - returns: A new fetcher result of the transformation of the original fetcher
- */
-public func =>><A: Fetcher, B: OneWayTransformer>(fetcher: A, transformer: B) -> BasicFetcher<A.KeyType, B.TypeOut> where A.OutputType == B.TypeIn {
-  return fetcher.transformValues(transformer)
-}

Carlos/KeyTransformation.swift

@@ -27,17 +27,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
-Applies a transformation to a cache level
-The transformation works by changing the type of the key the cache accepts
-Use this transformation when you use a domain specific key or a wrapper key that contains several values every cache level can choose from
-
-- parameter cache: The cache level you want to transform
-- parameter transformer: The transformation you want to apply
-
-- returns: A new cache level result of the transformation of the original cache level
-*/
-public func =>><A: CacheLevel, B: OneWayTransformer>(transformer: B, cache: A) -> BasicCache<B.TypeIn, A.OutputType> where A.KeyType == B.TypeOut {
-  return cache.transformKeys(transformer)
-}

Carlos/PostProcess.swift

@@ -1,8 +1,6 @@
 import Foundation
 import PiedPiper
 
-infix operator ~>>: MultiplicationPrecedence
-
 extension CacheLevel {
 
   /**
@@ -25,17 +23,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
-Adds a post-processing step to the get results of a CacheLevel
-
-As usual, if the transformation fails, the get request will also fail
-
-- parameter cache: The CacheLevel you want to decorate
-- parameter transformer: The OneWayTransformer that will be applied to every successful result of the CacheLevel. The transformer has to return the same type of the input type, and the transformation won't be applied when setting values on the cache level.
-
-- returns: A transformed CacheLevel that incorporates the post-processing step
-*/
-public func ~>><A: CacheLevel, B: OneWayTransformer>(cache: A, transformer: B) -> BasicCache<A.KeyType, A.OutputType> where A.OutputType == B.TypeIn, B.TypeIn == B.TypeOut {
-  return cache.postProcess(transformer)
-}

Carlos/ValueTransformation.swift

@@ -42,17 +42,3 @@ extension CacheLevel {
     )
   }
 }
-
-/**
-Applies a transformation to a cache level
-The transformation works by changing the type of the value the cache returns when succeeding
-Use this transformation when you store a value type but want to mount the cache in a pipeline that works with other value types
-
-- parameter cache: The cache level you want to transform
-- parameter transformer: The transformation you want to apply
-
-- returns: A new cache result of the transformation of the original cache
-*/
-public func =>><A: CacheLevel, B: TwoWayTransformer>(cache: A, transformer: B) -> BasicCache<A.KeyType, B.TypeOut> where A.OutputType == B.TypeIn {
-  return cache.transformValues(transformer)
-}

MIGRATING.md

@@ -1,3 +1,24 @@
+## Migrating from 0.8 to 0.9
+
+### Swift 3 support
+
+Please make sure to convert all usages of `Carlos` APIs to the Swift 3 counterparts. In most cases there won't be a big syntactic difference.
+
+### Deprecated functions
+
+All deprecated functions have been removed. This were of 2 types:
+
+- Global functions
+- Functions taking fetch closures or transformation closures
+
+For the first type, just use the corresponding protocol extension function.
+
+For the second type, please use `BasicFetcher` instead of fetch closures, and explicit `OneWayTransformationBox` instances instead of transformation closures.
+
+### Custom operators
+
+All custom operators have been removed. Please use the corresponding protocol extension functions instead. This may require some reordering of the objects.
+
 ## Migrating from 0.7 to 0.8
 
 ### `Promise` now has only an empty `init`.