anchor.diff:  
       /// Transforms a constrained value.
       type 'a Transformer =
  -        int64 -> Constraint -> 'a array -> ('a array * Output)
  +        int64 -> Constraint -> 'a array -> (Output * 'a array)
   
       [<RequireQualifiedAccess>]
       module Transformer =
  
positive.code:         /// Make a scope.
          let inline make<'a, 'b when 'a : struct> (getField : 'a -> 'b) (setField : 'b -> 'a -> 'a) : Scope<'a, 'b> =
              { In = Array.map getField
                Out = fun (fields, output) (targets : 'a array) -> (Array.map2 setField fields targets, output) }
  
      /// The base behavior type.
      type Behavior =
  
          /// Run the behavior over a single target.
          abstract Run : int64 -> Constraint -> obj -> (obj * Output)
  
          /// Run the behavior over multiple targets.
          abstract RunMany : int64 -> Constraint -> obj -> (obj * Output)
  
      /// Defines a generic behavior.
      type [<NoEquality; NoComparison>] Behavior<'a, 'b when 'a : struct> =
  
negative.code:                             let result = applyRange targetValue (value + scale (value2 - value, progressEase))
                              struct (targetLife, result))
                              targets
                      (Output.empty, targets)
              | EaseIn (value, value2) ->
                  fun _ _ targets ->
                      let targets =
  