my $tm = ... some map (or another filter)
my $filter = new TM::Tau::Filter (left => $tm);
$filter->sync_in; # this will pass on the sync in to the left operand
# after that, the filter itself holds the result (which is a map)
$filter->instances (....);

The variable $trafo2 then holds this expression, but nothing is actually computed at this stage. To trigger this process, the method sync_in can be used (read: apply). It will trigger the in-synchronisation of $trafo1 and that will pass it on to the $map. That will do something (or not) to ensure that the map is up-to-date relative to the resource it is possibly associated with. Once this is done, the filter $trafo1 will do its work. Once the result is available, $trafo2 will do its work.

Filters are not constrained in what they are doing. Some filters might only extract a particular portion out of a map. Others will make more complex conversions, say, to adapt to a different background ontology. Others will completely change the map, or compute new stuff from it. It is also possible to have transformers which actually do nothing, except than mediating between different formats a map is written in.

To specify what the transformation is supposed to do, you can either overload the method sync_in, or alternatively keep it and overload only transform:

sub transform {
my $self = shift; # this is the filter
my $map = shift; # this is the left operand map
.... # do whatever you need to do
$result = ..... # this might be your result
return $result; # return it
}

Your result will be used as content for the filter (which is a map itself, remember). See TM::Tau::Filter::Analyze for an example.

The default transformation is the empty one, i.e. the map is simply passed through (not copied, btw).