Updates := self.Updates.map toUpdates2();

--

mapping Update1::toUpdates2() : OrderedSet(Update2)  {	
--Count the VariableExpressions. For each one, create an object and add it to result.

var NewUpdate: Update2;

NewUpdate := object Update2 {
  --Some Attributes that I didn't show. These need to be mapped too.
};

result += NewUpdate; 
}

Updates += self.Updates.map toUpdates2()

Updates := self.Updates.map toUpdates2() -> flatten();

Sequence(OrderedSet(Update2))

modeltype MMA uses "...";
modeltype MMB uses "...";

transformation NewTransformation(in A:MMA, out B:MMB);

main() {
	log("#RootObjects:" + A.rootObjects()[Fam]->size().toString());
	A.rootObjects()[Fam]->map StartTrans();
}

mapping MMA::Fam::StartTrans() : MMB::Family {
  Member := self.ConsistsOf.map toMembers();
}

mapping MMA::Members::toMembers() : OrderedSet(MMB::Person) {

  self.Contain->forEach(Exp) {
  	result += object MMB::Person { Naam := Exp.Name };
    log("Name = " + Exp.Name);
  }
  	
}

modeltype MMA uses "http:///MMA.ecore";
modeltype MMB uses "http:///MMB.ecore";

transformation family(in A:MMA, out B:MMB);

main() 
{
   A.objects()[MMA::Family]->mapFamily();
}

mapping MMA::Family::mapFamily() : MMB::Family
{
	consistsOf := getElements (self.consistsOf.contain);
}

query getElements( el : Set(MMA::Person) ) : Set (MMB::Person) 
{
    var bset : Set (MMB::Person) := null;
    bset := el->iterate ( i : MMA::Person; r : Set(MMB::Person) = OrderedSet{} |  
                          r->including(object MMB::Person { name := i.name; }) );
	return bset;
}

...

mapping MMA::Fam::StartTrans() : MMB::Family {
  --Member := self.ConsistsOf.map toMembers();
  Member := QueryToMembers( self.ConsistsOf );
}

query QueryToMembers ( Parameter: Members ) : OrderedSet(MMB::Person) {
	var Persons: OrderedSet(MMB::Person);
	Parameter.Contain->forEach(Exp) {
		Persons += object MMB::Person { Naam := Exp.Name };
	};
	return Persons;
}

Persons += object MMB::Person { Naam := Exp.Name; Hobbies := Exp.Pastime->map toHobbies(); };