anchor.diff:                  let (particles, outputs) = Behavior<'a, 'b>.run time this (particlesObj :?> 'a array)
                   (particles :> obj, outputs)
   
  -    /// A collection of behaviors.
  -    type [<NoEquality; NoComparison>] Behaviors =
  +    /// A composition of behaviors.
  +    type [<NoEquality; NoComparison>] CompositionalBehaviors =
           { Behaviors : Behavior FStack }
   
  -        /// The empty behavior.
  +        /// The empty compositional behavior.
           static member empty =
               { Behaviors = FStack.empty }
   
  -        /// Combine two behaviors.
  +        /// Add a behavior.
           static member add behavior behaviors =
               { Behaviors = FStack.conj behavior behaviors.Behaviors }
   
  -        /// Combine multiple behaviors.
  +        /// Add multiple behaviors.
           static member addMany behaviorsMany behaviors =
               { Behaviors = Seq.fold (fun behaviors behavior -> FStack.conj behavior behaviors) behaviors.Behaviors behaviorsMany }
   
  -        /// Make a collection of behaviors from a sequence of behaviors.
  +        /// Make a compositional behavior from a sequence of behaviors.
           static member ofSeq seq =
  -            Behaviors.addMany seq Behaviors.empty
  -
  -        /// Run the behaviors over an array.
  +            CompositionalBehaviors.addMany seq CompositionalBehaviors.empty
  +
  +        /// Run the compositional behaviors over an array.
           static member run time behaviors (particles : 'a array) =
               let (particles, outputs) =
                   FStack.fold (fun (particles, output) (behavior : Behavior) ->
  
positive.code:     /// A basic particle.
      type [<NoEquality; NoComparison; Struct>] BasicParticle =
          { mutable Life : Life
            Bod : Body
            Siz : Vector2
            Off : Vector2
            Ins : Vector4
            Col : Color
            Glo : Color
            Flp : Flip }
          interface Particle with member this.Life with get () = this.Life and set value = this.Life <- value
          static member inline bod = Scope.make (fun pex -> pex.Bod) (fun bod pex -> { pex with Bod = bod })
          static member inline col = Scope.make (fun pex -> pex.Col) (fun col pex -> { pex with Col = col })
          static member inline ins = Scope.make (fun pex -> pex.Ins) (fun ins pex -> { pex with Ins = ins })
  
      /// A basic particle emitter.
      type BasicEmitter = Emitter<BasicParticle>
negative.code:           mutable ParticleIndex : int // operates as a ring-buffer
            Particles : 'a array // operates as a ring-buffer
            Initializer : int64 -> Constraint -> 'a Emitter -> 'a
            InPlaceBehavior : int64 -> Constraint -> 'a Emitter -> Output
            CompositionalBehaviors : CompositionalBehaviors
            Constraint : Constraint
            Rate : single
            Body : Body
  