  }
  ```
  */
-public typealias CompletionHandler = (_: Completion) -> ()
-
-// !!! TO DEPRECATED we use Bidirectionnal XPC
-
-/*
+public typealias CompletionHandler = (_ conpletionState: Completion) -> ()
+
+public var VoidCompletionHandler:CompletionHandler = { completion in }
+
+public var VoidProgressionHandler:ProgressionHandler = { progression in }
+
+
+/**
  A composed Closure with a progress and acompletion section
  Generally Used in XPC facades because we can pass only one handler per XPC call
  To consume and manipulate we generally split the ComposedHandler by calling Handlers.handlersFrom(composed)

public typealias ComposedHandler = (_ progressionState: Progression?, _ completionState: Completion?)->()




// Reactive Protocol
protocol Reactive {
    var reactiveHandlers: Handlers { get }
}


// MARK: - Handlers

import Foundation


/*
 
# Notes on Handlers
 
## We expose 6 Handlers

 - CompletionHandler : a closure with a completion state
 - ProgressionHandler : a closure with a progression state
 - Handlers : a class that allows to compose completion an progression Handlers.
 - ComposedHandler : a composed closure
 - VoidCompletionHandler : a void handler that can be used as place holder
 - VoidProgressionHandler : a void handler that can be used as place holder

 ## We should not use ComposedHandler in XPC context (!)

 Only one closure can be called per XPC call.
 So to monitor progression from an XPC : **we use Bidirectionnal XPC + Monitoring protocol for the progress**

 ## You can create a code Snippets for  :
 
     ```
         let onCompletion:CompletionHandler = { completion in
         }
    ```
    ```
        let onProgression:ProgressHandler = { progression in
        }
    ```
 ## Chaining Handlers:

    You can chain an handler but keep in mind it can produce retain cycle
 ```
     let onCompletion:CompletionHandler = { completion in
        previousHandler(completion) //<--- you can chain a previous handler
     }  
 ```
 
 ## You can instanciate a ComposedHandler :

     ```
         let handler: ComposedHandler = {(progressionState, completionState) -> Void in
            if let progression=progressionState {
            }
            if let completion=completionState {
            }
         }
     ```
*/



// MARK: -

/*
 ProgressionHandler

```
let onProgression:ProgressionHandler = { progression in
    previousHandler(progression)// Invoke
    ...
}
```
*/
public typealias ProgressionHandler = (_ progressionState: Progression) -> ()

/*
 CompletionHandler
