anchor.diff:              CompositionalBehaviors.addMany seq CompositionalBehaviors.empty
   
           /// Run the compositional behaviors over an array.
  -        static member run time behaviors (particles : 'a array) =
  +        static member run time behaviors constrain (particles : 'a array) =
               let (particles, outputs) =
                   FStack.fold (fun (particles, output) (behavior : Behavior) ->
  -                    let (particles2, output2) = behavior.Run time particles
  +                    let (particles2, output2) = behavior.Run time constrain particles
                       (particles2, output + output2))
                       (particles :> obj, NoOutput)
                       behaviors.Behaviors
  
positive.code:         abstract Life : Life with get, set
  
      /// A particle constraint.
      type [<StructuralEquality; NoComparison; CompilationRepresentation (CompilationRepresentationFlags.UseNullAsTrueValue)>] Constraint =
          | Rectangle of Vector4
          | Circle of single * Vector2
          | Constraints of Constraint array
          | Unconstrained // OPTIMIZATION: elide Option indirection
  
          static member (+) (constrain, constrain2) =
              match (constrain, constrain2) with
              | (Unconstrained, Unconstrained) -> constrain // OPTIMIZATION: elide Constraint ctor
              | (_, Unconstrained) -> constrain
              | (Unconstrained, _) -> constrain2
              | (_, _) -> Constraints [|constrain; constrain2|]
  
      /// The output of a particle behavior.
  
negative.code: 
      /// Transforms a particle value.
      type 'a Transformer =
          single -> Constraint -> 'a -> struct ('a * Output)
  
      [<AutoOpen>]
      module Transformer =
  
          /// Pipe two transformers.
          let pipe (transformer : 'a Transformer) (transformer2 : 'a Transformer) : 'a Transformer =
              fun progress constrain a ->
                  let struct (a, output) = transformer progress constrain a
                  let struct (a, output2) = transformer2 progress constrain a
                  struct (a, output + output2)
  
          /// Pipe multiple transformers.
  