 	}
 }
 
-func +<T>(lhs: T, rhs: T) -> T where T: Animatable {
-	return T.composed(from: zip(lhs.components, rhs.components).flatMap { $0.0 + $0.1 })
-}
-
-func -<T>(lhs: T, rhs: T) -> T where T: Animatable {
-	return T.composed(from: zip(lhs.components, rhs.components).flatMap { $0.0 - $0.1 })
-}
-
-public struct PhysicsState<T> where T: Animatable {
-
-	public var value: T
-
-	public var velocity: T
-}
-
+/// Your fast and friendly physics based animator.
 public final class YapAnimator<T>: YapAnimatorCommonInterface where T: Animatable {
 
 	// Animation Variables
 
+	/// The target value of the animator
 	public var toValue: T {
 		didSet {
 			if oldValue.components != toValue.components {
+				targetedCompletion(self, false)
+				targetedCompletion = { _ in }
+				targetedAction = { _ in }
 				setNeedsUpdate()
 			}
 		}
 	}
 
+	/// Set the target value of the animator
+	///
+	/// - Parameter to: The target value of the animator
+	/// - Parameter action: This closure gets called every frame of the animation just like the `action` that was defined in the animator's constructor but with a very important difference: **It is only called and retained as long as this function is not called again or the toValue does not change.**
+	/// - Parameter animator: The associated `YapAnimator`
+	/// - Parameter completion: This closure gets called when the animator comes to rest or is stopped otherwise. The `Bool` value passed into this closure will be `true` if the animator comes to rest at the `toValue` or `false` if the animator is stopped for any other reason. This is just like the `completion` in the constructor but with a very important difference: **It is only called and retained as long as this function is not called again or the toValue does not change.**
+	/// - Parameter animator: The associated `YapAnimator`
+	/// - Parameter finished: `true` if the animator comes to rest at the `toValue` or `false` if the animator is stopped for any other reason.
+	func animate(to: T, action: @escaping (_ animator: YapAnimator) -> Void = { _ in }, completion: @escaping (_ animator: YapAnimator, _ finished: Bool) -> Void = { _ in }) {
+		// setting the toValue clears any extant targetedAction
+		toValue = to
+		targetedAction = action
+		// will cancel any in-flight completion
+		targetedCompletion(self, false)
+		targetedCompletion = completion
+	}
+
+	/// A value defining the bounciness of the animator. A value of `0` represents a critically dampened spring — one that moves as quickly to the target value without overshooting. A value of `1` represents an aesthetically pleasing bounce. This value can be set to values under or over this range.
 	public var bounciness = 0.0 {
 		didSet {
 			if oldValue != bounciness {

		}
	}

	public var speed = 1.0 {
		didSet {
			if oldValue != speed {

		}
	}

	/// Contains the in-flight value and velocity of the animator
	public var current: PhysicsState<T>

	fileprivate var accumulator = 0.0

	fileprivate var forces = T.zero()

	/// Applies an instantaneous push (using positive forces) or pull (using negative forces) to the animation
	///
	/// - Parameter force: The force to apply to the animator
	public func apply(force newForce: T) {

		forces = forces + newForce
		setNeedsUpdate()
	}

	/// Cancels the animator if it is in-flight
	public func stop() {

		if state == .began || state == .updated {
			stopExecution()
		}
	}

	/// Create a new `Yap Animator`
	///
	/// - Parameter initialValue: Set the initial value of the animator
	/// - Parameter willBegin: An optional closure that returns the 'model value' of your animated value. This is useful to synchronize the animator with a value that may get set outside of the scope of the animator.
	/// - Parameter completion: An optional closure that gets called when the animator comes to rest or is stopped otherwise. The `Bool` value passed into this closure will be `true` if the animator comes to rest at the `toValue` or `false` if the animator is stopped for any other reason.
	/// - Parameter action: A closure that is called at every frame of the animation. Use this closure to apply the animator's `current.value` to the value(s) that you wish to animate.
	public init(initialValue: T,
	            willBegin: ((YapAnimator) -> Void)? = nil,
	            completion: ((YapAnimator, _ finished: Bool) -> Void)? = nil,
	            action: ((YapAnimator) -> Void)?)
	{
		self.current = PhysicsState(value: initialValue, velocity: T.zero())
		self.toValue = initialValue
