anchor.diff:            Transformer : 'b Transformer }
   
           /// Run the behavior over an array of particles.
  -        static member run time (behavior : Behavior<'a, 'b>) (particles : 'a array) =
  +        static member run time (constrain : Constraint) (behavior : Behavior<'a, 'b>) (particles : 'a array) =
               let particles2 = Array.map (behavior.Scope.In time) particles
  -            let particles3 = Array.map (fun struct (progress, field) -> behavior.Transformer progress field) particles2
  +            let particles3 = Array.map (fun struct (progress, field) -> behavior.Transformer progress constrain field) particles2
               let particles4 = Array.map2 behavior.Scope.Out particles3 particles
               let particles5 = Array.map fst' particles4
               let outputs = particles4 |> Array.filter (function struct (_, NoOutput) -> false | struct (_, _) -> true) |> Array.map snd'
  
positive.code:     type Behavior =
  
          /// Run the behavior.
          abstract Run : int64 -> obj -> (obj * Output)
  
      /// Defines a particle behavior.
      type [<NoEquality; NoComparison>] Behavior<'a, 'b when 'a : struct> =
  
negative.code:             (particles5, output)
  
          interface Behavior with
              member this.Run time constrain particlesObj =
                  let (particles, outputs) = Behavior<'a, 'b>.run time constrain this (particlesObj :?> 'a array)
                  (particles :> obj, outputs)
  
      /// A composition of behaviors.
  