sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/kernel/Performances.kerml

@@ -0,0 +1,293 @@
+standard library package Performances {
+	doc
+	/*
+	 * This package defines classifiers and features that related to the typing of performances and evaluations.
+	 */
+
+	private import Base::Anything;
+	private import Base::things;
+	private import Occurrences::Occurrence;
+	private import Occurrences::occurrences;
+	private import Occurrences::HappensDuring;
+	private import Objects::Object;
+	private import Links::BinaryLink;
+	private import Metaobjects::Metaobject;
+	private import Transfers::Transfer;
+	private import Transfers::transfers;
+	private import Transfers::TransferBefore;
+	private import Transfers::transfersBefore;
+	private import ScalarValues::*;
+	private import SequenceFunctions::includes;
+	
+	abstract behavior Performance specializes Occurrence disjoint from Object {
+		doc
+		/*
+		 * Performance is the most general class of behavioral Occurrences that may be performed over time.
+		 */
+
+		feature self: Performance redefines Occurrence::self;
+		
+		feature involvedObjects: Object[0..*] {
+			doc
+			/*
+			 * Objects that are involved in this Performance.
+			 */
+		}
+		
+		feature performers: Object[0..*] subsets involvedObjects {
+			doc
+			/*
+			 * Objects that enact this Performance.
+			 */
+		}
+		
+		feature redefines isDispatch default true;
+  		feature redefines dispatchScope default thisPerformance;
+  		
+		step enclosedPerformances: Performance[0..*] subsets performances, timeEnclosedOccurrences
+			intersects performances, timeEnclosedOccurrences {
+			doc
+			/*
+			 * timeEnclosedOccurrences of this Performance that are also Performances.
+			 */
+		}
+		
+		feature thisPerformance: Performance [1] default self {
+			doc
+			/*
+			 * Defaults to the root of the subperformance composition tree.
+			 */
+		}
+		connector :HappensDuring from [1] self to [1] thisPerformance; 
+		
+		composite step subperformances: Performance[0..*] subsets enclosedPerformances, suboccurrences
+			intersects enclosedPerformances, suboccurrences {
+			doc
+			/*
+			 * enclosedPerformances that are composite. 
+			 */
+		
+			feature redefines this default (that as Performance).this {
+				doc
+				/*
+				 * The default "this" context of a subperformance is the same as that of its owning Performance.
+				 * This means that the context for any Performance that is in a composition tree rooted
+				 * in a Performance that is not itself owned by an Object is the root Performance. If the
+				 * root Performance is an ownedPerformance of an Object, then that Object is the context.
+				 */
+			}
+		
+			feature redefines thisPerformance default (that as Performance).thisPerformance;
+		}		
+	}
+	
+	abstract function Evaluation specializes Performance {
+		doc
+		/*
+		 * Evaluation is the most general class of functions that may be evaluated to compute
+		 * a result.
+		 */
+	 
+		return result: Anything[0..*] nonunique;
+	}
+	
+	abstract predicate BooleanEvaluation specializes Evaluation {
+		doc
+		/*
+		 * BooleanEvaluation is a specialization of Evaluation that is the most general class of
+		 * Predicates that may be evaluated to produce a Boolean truth value.
+		 */
+	 
+		return : Boolean[1];
+	}
+	
+	abstract function MetadataAccessEvaluation specializes Evaluation {
+		doc
+		/*
+		 * MetadataAccessEvaluation is a specialization of Evaluation for the case of MetadataAccessExpressions.
+		 */
+		
+		return : Metaobject[1..*];
+	}
+	
+	abstract function LiteralEvaluation specializes Evaluation {
+		doc
+		/*
+		 * LiteralEvaluation is a specialization of Evaluation for the case of LiteralExpressions.
+		 */
+	 
+		return : ScalarValue[1];
+	}
+	
+	abstract predicate LiteralBooleanEvaluation specializes LiteralEvaluation, BooleanEvaluation
+		intersects LiteralEvaluation, BooleanEvaluation {
+		doc
+		/*
+		 * LiteralBooleanEvaluation is a specialization of LiteralEvaluation for the case of LiteralBooleans.
+		 * It is also a predicate and thus a specialization of BooleanEvaluation. 
+		 */
+	 
+		return : Boolean[1];
+	}
+	abstract function LiteralIntegerEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralIntegerEvaluation is a specialization of LiteralEvaluation for the case of LiteralIntegers.
+		 */
+	 
+		return : Integer[1];
+	}
+
+	abstract function LiteralRationalEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralRationalEvaluation is a specialization of LiteralEvaluation for the case of LiteralRationals.
+		 * (Note: Return type is Real to allow easy type conformance of LiteralRationals when a Real result is expected.)
+		 */
+	 
+		return : Real[1];
+	}
+	
+	abstract function LiteralStringEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralStringEvaluation is a specialization of LiteralEvaluation for the case of LiteralStrings.
+		 */
+	 
+		return : String[1];
+	}
+	
+	function NullEvaluation specializes Evaluation {
+		doc
+		/*
+		 * NullEvaluation is a specialization of Evaluation for the case of NullExpressions.
+		 */
+	 
+		return : Anything[0..0];
+	}
+
+	assoc all InvolvedIn specializes BinaryLink { 
+		doc
+		/*
+		 * InvolvedIn asserts that the involvedObject is involved in the Behavior carried out by the 
+		 * involvingPerformance.
+		 */
+		 
+		end feature involvedObject: Object redefines source crosses involvingPerformance.involvedObjects;
+		end feature involvingPerformance: Performance redefines target crosses involvedObject.involvingPerformances;
+	}
+	
+	assoc all Performs specializes InvolvedIn {
+		doc
+		/*
+		 * Performs asserts that the performer enacts the Behavior carried out by the performance.
+		 */
+	
+	 	end feature performerObject: Object redefines involvedObject crosses performance.performers;
+	 	end feature performance: Performance redefines involvingPerformance crosses performerObject.enactedPerformances;
+	 }
+
+	abstract step performances: Performance[0..*] nonunique subsets occurrences {
+		doc
+		/*
+		 * performances is the most general feature for performances of Behaviors.
+		 */
+	}
+	
+	abstract expr evaluations: Evaluation[0..*] nonunique subsets performances {
+		doc
+		/*
+		 * evaluations is a specialization of performances for evaluations of Functions.
+		 */
+	}
+	
+	abstract expr constructorEvaluations [0..*] nonunique subsets evaluations  {
+	    doc
+	    /*
+	     * constructorEvaluations is a specialization of evaluations that restricts the multiplicity 
+	     * of its result parameter to 1..1, requiring a constructorEvaluation to result in a single value.
+	     */
+	     
+	     return result [1..1];
+	}
+	
+	abstract expr booleanEvaluations: BooleanEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * booleanEvaluations is a specialization of evaluations restricted to type BooleanEvaluation.
+		 */
+	}
+	
+	abstract expr trueEvaluations subsets booleanEvaluations {
+		doc
+		/*
+		 * trueEvaluations is a subset of booleanEvaluations that result in true. It is the most general
+		 * feature of invariants that are not negated. 
+		 */
+	
+		private feature trueValue = true;
+		binding result = trueValue;
+	}
+	
+	abstract expr falseEvaluations subsets booleanEvaluations {
+		doc
+		/*
+		 * falseEvaluations is a subset of booleanEvaluations that result in false. It is the most general
+		 * feature of invariants that are negated.
+		 */
+	
+        private feature falseValue = false;
+        binding result = falseValue;
+	}
+	
+	abstract expr metadataAccessEvaluations: MetadataAccessEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * metadataAccessEvaluations is a specialization of evaluations restricted to type MetadataAccessEvaluation. 
+		 */
+	}
+	
+	abstract expr literalEvaluations: LiteralEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.
+		 */
+	}
+	
+	abstract expr literalBooleanEvaluations: LiteralBooleanEvaluation[0..*] nonunique subsets literalEvaluations, booleanEvaluations
+		intersects literalEvaluations, booleanEvaluations {
+		doc
+		/*
+		 * literaBooleanlEvaluations is a specialization of literalEvaluations and booleanEvaluations restricted 
+		 * to type LiteralBooleanEvaluation.
+		 */
+	}
+	
+	abstract expr literalIntegerEvaluations: LiteralIntegerEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.
+		 */
+	}
+	
+	abstract expr literalRationalEvaluations: LiteralRationalEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalRationalEvaluations is a specialization of literalEvaluations restricted to type LiteralRationalEvaluation.
+		 */
+	}
+	
+	abstract expr literalStringEvaluations: LiteralStringEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalStringEvaluations is a specialization of literalEvaluations restricted to type LiteralStringEvaluation.
+		 */
+	}
+	
+	abstract expr nullEvaluations: NullEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * nullEvaluations is a specialization of evaluations restricted to type NullEvaluation.
+		 */
+	}
+}

sysmlpy/library/kernel/RationalFunctions.kerml

@@ -0,0 +1,49 @@
+standard library package RationalFunctions {
+	doc
+	/*
+	 * This package defines Functions on Rational values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function rat { in numer: Integer[1]; in denum: Integer[1]; return : Rational[1]; }
+	function numer { in rat: Rational[1]; return : Integer[1]; }
+	function denom { in rat: Rational[1]; return : Integer[1]; }
+	
+	function abs specializes RealFunctions::abs { in x: Rational[1]; return : Rational[1]; }
+
+	function '+' specializes RealFunctions::'+' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }
+	function '-' specializes RealFunctions::'-' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }
+	function '*' specializes RealFunctions::'*' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '/' specializes RealFunctions::'/' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '**' specializes RealFunctions::'**' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '^' specializes RealFunctions::'^' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	
+	function '<' specializes RealFunctions::'<' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '>' specializes RealFunctions::'>' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '<=' specializes RealFunctions::'<=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '>=' specializes RealFunctions::'>=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+
+	function max specializes RealFunctions::max { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function min specializes RealFunctions::min { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+
+	function '==' specializes RealFunctions::'==' { in x: Rational[0..1]; in y: Rational[0..1]; return : Boolean[1]; }
+	
+	function gcd{ in x: Rational[1]; in y: Rational[1]; return : Integer[1]; }
+		
+	function floor specializes RealFunctions::floor { in x: Rational[1]; return : Integer[1]; }
+	function round specializes RealFunctions::round { in x: Rational[1]; return : Integer[1]; }
+	
+	function ToString specializes RealFunctions::ToString { in x: Rational[1]; return : String[1]; }
+	function ToInteger{ in x: Rational[1]; return : Integer[1]; }
+	function ToRational{ in x: String[1]; return : Rational[1]; }
+	
+	function sum specializes RealFunctions::sum { in collection: Rational[0..*];
+		return : Rational[1] default NumericalFunctions::sum0(collection, rat(0, 1));
+	}
+	
+	function product specializes RealFunctions::product { in collection: Rational[0..*];
+		return : Rational[1] default NumericalFunctions::product1(collection, rat(1, 1));
+	}	
+}

sysmlpy/library/kernel/RealFunctions.kerml

@@ -0,0 +1,56 @@
+standard library package RealFunctions {
+	doc
+	/*
+	 * This package defines Functions on Real values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function re :> ComplexFunctions::re{ in x: Real[1]; 
+        return : Real[1] = x;
+	}
+	function im :> ComplexFunctions::im{ in x: Real[1]; 
+        return : Real[1] = 0.0;
+	}
+	
+	function abs specializes ComplexFunctions::abs { in x: Real[1]; return : Real[1]; }
+	function arg specializes ComplexFunctions::arg { in x: Real[1]; 
+        return : Real[1] = 0.0;
+	}
+
+	function '+' specializes ComplexFunctions::'+' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }
+	function '-' specializes ComplexFunctions::'-' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }
+	function '*' specializes ComplexFunctions::'*' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '/' specializes ComplexFunctions::'/' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '**' specializes ComplexFunctions::'**' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '^' specializes ComplexFunctions::'^' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	
+	function '<' specializes NumericalFunctions::'<' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '>' specializes NumericalFunctions::'>' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '<=' specializes NumericalFunctions::'<=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '>=' specializes NumericalFunctions::'>=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+
+	function max specializes NumericalFunctions::max { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function min specializes NumericalFunctions::min { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+
+	function '==' specializes ComplexFunctions::'==' { in x: Real[0..1]; in y: Real[0..1]; return : Boolean[1]; }
+			
+	function sqrt{ in x: Real[1]; return : Real[1]; }
+
+	function floor{ in x: Real[1]; return : Integer[1]; }
+	function round{ in x: Real[1]; return : Integer[1]; }
+	
+	function ToString specializes ComplexFunctions::ToString { in x: Real[1]; return : String[1]; }
+	function ToInteger{ in x: Real[1]; return : Integer[1]; }
+	function ToRational{ in x: Real[1]; return : Rational[1]; }
+	function ToReal{ in x: String[1]; return : Real[1]; }
+	
+	function sum specializes ComplexFunctions::sum { in collection: Real[0..*]; 
+        return : Real default NumericalFunctions::sum0(collection, 0.0);
+	}
+	
+	function product specializes ComplexFunctions::product { in collection: Real[0..*]; 
+        return : Real default NumericalFunctions::product1(collection, 1.0);
+	}	
+}

sysmlpy/library/kernel/ScalarFunctions.kerml

@@ -0,0 +1,33 @@
+standard library package ScalarFunctions {
+	doc
+	/*
+	 * This package defines abstract functions that specialize the DataFunctions for use with ScalarValues. 
+	 */
+
+	public import ScalarValues::*;
+	
+	abstract function '+' specializes DataFunctions::'+' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }
+	abstract function '-' specializes DataFunctions::'-' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }
+	abstract function '*' specializes DataFunctions::'*' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '/' specializes DataFunctions::'/' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '**' specializes DataFunctions::'**' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '^' specializes DataFunctions::'^' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '%' specializes DataFunctions::'%' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function 'not' specializes DataFunctions::'not' { in x: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function 'xor' specializes DataFunctions::'xor' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+
+	abstract function '~' specializes DataFunctions::'~' { in x: ScalarValue[1]; return : ScalarValue[1]; }	
+	abstract function '|' specializes DataFunctions::'|' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '&' specializes DataFunctions::'&' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function '<' specializes DataFunctions::'<' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '>' specializes DataFunctions::'>' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '<=' specializes DataFunctions::'<=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '>=' specializes DataFunctions::'>=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	
+	abstract function max specializes DataFunctions::max { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function min specializes DataFunctions::min { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function '..' specializes DataFunctions::'..' { in lower: ScalarValue[1]; in upper: ScalarValue[1]; return : ScalarValue[0..*]; }
+}

sysmlpy/library/kernel/ScalarValues.kerml

@@ -0,0 +1,23 @@
+standard library package ScalarValues {
+	doc
+	/*
+	 * This package contains a basic set of primitive scalar (non-collection) data types. 
+	 * These include Boolean and String types and a hierarchy of concrete Number types, from 
+	 * the most general type of Complex numbers to the most specific type of Positive integers.</p>
+	 */
+
+	private import Base::DataValue;
+	
+	abstract datatype ScalarValue specializes DataValue;
+	datatype Boolean specializes ScalarValue;
+	datatype String specializes ScalarValue;
+	abstract datatype NumericalValue specializes ScalarValue;
+	
+    abstract datatype Number specializes NumericalValue;
+	datatype Complex specializes Number;
+	datatype Real specializes Complex;	
+	datatype Rational specializes Real;
+	datatype Integer specializes Rational;
+	datatype Natural specializes Integer;
+    datatype Positive specializes Natural;	
+}		

sysmlpy/library/kernel/SequenceFunctions.kerml

@@ -0,0 +1,111 @@
+standard library package SequenceFunctions {
+	doc
+	/*
+	 * This package defines functions that operate on general sequences of values. (For functions that
+	 * operate on Collection values, see CollectionFunctions.)
+	 */
+
+	private import Base::Anything;
+	private import Occurrences::SelfSameLifeLink;
+	private import ScalarValues::*;
+	private import ControlFunctions::*;
+	
+	function '#' specializes BaseFunctions::'#' { in seq: Anything[0..*] ordered nonunique; in index: Positive[1];
+		return : Anything[0..1];
+	}
+	
+	function equals{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique; 
+		return : Boolean[1] =
+			size(x) == size(y) and
+			(1..size(x))->forAll {in i; x#(i) == y#(i)};
+	}
+
+	function same{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique;
+		return : Boolean[1] =
+			size(x) == size(y) and
+			(1..size(x))->forAll {in i; x#(i) === y#(i)};
+	}
+
+	function size{ in seq: Anything[0..*] nonunique;
+		return : Natural[1] = if isEmpty(seq)? 0 else size(tail(seq)) + 1;
+	}
+	function isEmpty{ in seq: Anything[0..*] nonunique;
+		return : Boolean[1] = seq == null;
+	}
+	function notEmpty{ in seq: Anything[0..*] nonunique;
+		return : Boolean[1] = not isEmpty(seq);
+	}
+	function includes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq2->forAll {in x; seq1->exists{in y; x == y}};
+	}
+	function includesOnly{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq1->includes(seq2) and seq2->includes(seq1);
+	}
+	function excludes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq2->forAll {in x; seq1->excludes(x)};
+	}
+	
+	function union{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = (seq1, seq2);
+	}
+	function intersection{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = seq1->select {in x; seq2->includes(x)};
+	}
+	function including{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = union(seq, values);
+	}
+	function includingAt{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		in index: Positive[1];
+		return : Anything[0..*] ordered nonunique = 
+			(seq->subsequence(1, index - 1), values, seq->subsequence(index + 1));
+	}
+	function excluding{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];
+		return : Anything[0..*] ordered nonunique = seq->reject {in x; values->includes(x)};
+	}
+	function excludingAt{ in seq: Anything[0..*] ordered nonunique;
+		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;
+		return : Anything[0..*] ordered nonunique = 
+			(seq->subsequence(1, startIndex - 1), seq->subsequence(endIndex + 1));
+	}
+	
+	function subsequence{ in seq: Anything[0..*] ordered nonunique; 
+		in startIndex: Positive[1]; in endIndex: Positive[1] default size(seq);
+		return : Anything[0..*] = (startIndex..endIndex)->collect {in i; seq#(i)};
+	}
+	function head{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..1] = seq#(1);
+	}
+	function tail{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = subsequence(seq, 2);
+	}
+	function last{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..1] = seq#(size(seq));
+	}
+	
+	behavior add { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		private feature newSeq = seq->including(values);
+		feature redefines endShot: add {
+			binding seq = newSeq;
+		}
+	}	
+	behavior addAt { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		in index: Positive[1];
+		private feature newSeq = seq->includingAt(values, index);
+		feature redefines endShot: addAt {
+			binding seq = newSeq;
+		}
+	}
+	behavior remove{ inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];
+		private feature newSeq = seq->excluding(values);
+		feature redefines endShot: remove {
+			binding seq = newSeq;
+		}
+	}
+	behavior removeAt{ inout seq: Anything[0..*] ordered nonunique;
+		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;
+		private feature newSeq = seq->excludingAt(startIndex, endIndex);
+		feature redefines endShot: removeAt {
+			binding seq = newSeq;
+		}
+	}
+}