In the following sections, you will find many examples of declarations, definitions, and uses of functions.

The collections in Kermeta implement several functions based on lambda expression. These ones are very useful for model navigation.

Example 1: closure definition for collection iterator-like in Kermeta

aCollection.each { e | 
    /* do something with each element e of this collection */
}

See Section 2.15, “ Collections ” for other existing functions on collections.

Example 2: another useful function that is defined on Integer : the function times

10.times { i | stdio.writeln(i.toString) } // prints 0 to 9 

Notice that you can also write some complex code in the function, using internal variables, etc. In such a case, the last statement evaluation will be the returned result of the lambda expression (provided it is declared to return something)

Example 3 : "complex"" code in a lambda expression

aCollection.each { e | 
    stdio.writeln("I am complex code!"
    stdio.writeln("Element : " + e.toString)
    var i : Integer init 5
    i := i + 132458
}

Example 4 : postponing parameter evaluation in the andThen operation

The operation andThen and orElse of Boolean use the ability of functions to postpone the parameter evaluation. This allows to implement the expected behavior without adding new construct to the language.

        // this kind of code allows to avoid a cast exception on the second test
        if cl.isInstanceOf(NamedElement).andThen{|	cl.asType(NamedElement).name == "foo"} then
        	// do something...
        end

Example 5 : using operation that use a function with several inputs

aCollection.indexedEach { e, eachContext | 
	stdio.write("element "+ eachContext.index.toString + ": " + e.toString)
	if(!eachContext.isLast) then stdio.writeln(",") end 
  }

aCollectionOfNamedElement.forAllCpl{s1,s2| (s1.name==s2.name).implies(s1==s2)}

You can also define your own functions, by declaring an operation, with a parameter as a function using the syntax described in Section 2.19.1, “ Syntax ” .

Example : definition of functions for collections

abstract class Collection<G>
{     
     /** * runs func on each element of the collection */
     operation each(func : <G -> Object>) : Void is do
         from var it : Iterator<G> init iterator
         until it.isOff
         loop
             func(it.next)
         end
      end

     /** * checks that the condition is true on all the element of the collection * returns true if the collection is empty */
     operation forAll(func : <G -> Boolean>) : Boolean is do
         var test : Boolean init true
         from var it : Iterator<G> init iterator
         until it.isOff
         loop
            test := test and func(it.next)
         end
         result := test
     end
}

You can also define lambda expression as variable. This can be useful if you don't want to ( or can't) modify the class.

With one Integer argument and returning an Integer.

var aLambdaExp : <Integer->Integer>
var aLambdaResult : Integer
aLambdaExp :=  { i : Integer | i.plus(4) }
// aLambdaResult equals 7
aLambdaResult := aLambdaExp(3)

var aLambdaExp : <[Integer, Integer]->Integer>
var aLambdaResult : Integer
aLambdaExp :=  { i : Integer, j : Integer | i * j }
// aLambdaResult equals 12
aLambdaResult := aLambdaExp(3, 4)

var init_set : Set<Integer> := Set<Integer>.new
init_set.add(32)
init_set.add(23)
init_set.add(41)

// This sequence equals : [320, 230, 410]
var sequence : Sequence<Integer> := init_set.collect { element | element*10}

The code within the function can be as complex as you want, using internal variables, etc.

var factoExp : <Integer->Integer>
    factoExp :=  { n : Integer | 
        var fact : Integer := 1
        from var x : Integer := 1 
        until x > n 
        loop
            fact := fact * x 
            x:=x+1
        end
        fact // return fact as the result of the function
        //shorter alternative ;-)... if n<=1 then 1 else factoExp(n -1) * n end
    }
    var cnkExp : <[Integer, Integer]->Integer>
    cnkExp :=  { n : Integer, k : Integer |
        factoExp(n) / (factoExp(k) * factoExp(n-k))
    }

When starting to use the lambda expression you can define some useful design patterns. One of them is the ability to propose an each that traverses all the owned element of a given metamodel. For some usage, this can be an interresting alternative to the visitor design pattern.

Let's have the following metamodel:

class NamedElement {
	attribute name : String
}
class A inherits NamedElement {
	attribute ownedAs : A[0..*]
}
class B inherits A {
	attribute ownedBs : B[0..*]
}
class C inherits A {
	attribute ownedBs : B[0..*]
	attribute ownedC : C
}

It would be nice to be able to call a simple lambda on all the elements directly owned by an element. This can be done by adding an operation using the following pattern:

aspect class NamedElement {
	operation eachOwnedElement(func : <NamedElement -> Void>) : Void is do
		// String attributes are value, so they aren't really "owned"  
	end
}
aspect class A inherits NamedElement {
	operation eachOwnedElement(func : <NamedElement -> Void>) : Void is do
		super[NamedElement](func)
		self.ownedAs.each{ e |
			func(e)
		}
	end
}
aspect class B inherits A {
	operation eachOwnedElement(func : <NamedElement -> Void>) : Void is do
		super[A](func) // makes sure to call func on attributes inherited from A
		self.ownedBs.each{ e |
			func(e)
		}
	end
}
aspect class C inherits A {
	operation eachOwnedElement(func : <NamedElement -> Void>) : Void is do
		super[A](func) // makes sure to call func on attributes inherited from A
		self.ownedBs.each{ e |
			func(e)
		}
		if(not ownedC.isVoid) then
			func(ownedC)
		end
	end
}

Then a call like the following will ensure to traverse all the directly owned elements.

var c : C := // initialize it with a complex model :-)
// write the name of all the elements directly  contained by c
c.eachOwnedElement{ aNamedElement | stdio.writeln(aNamedElement.name) }

// collect all the elements directly contained by c
var ownedElements : Sequence<Object> := Sequence<Object>.new
c.eachOwnedElement{ aNamedElement | ownedElements.add(aNamedElement) }
stdio.writeln("ownedElements.size = "+ ownedElements.size.toString)

It is then easy to extend this pattern to traverse the directly and indirectly owned elements.

aspect class NamedElement {
	operation eachAllOwnedElement(func : <NamedElement -> Void>) : Void is do			
		eachOwnedElement{e|
			func(e) 
			e.eachAllOwnedElement{child|func(child)} 
		}
	end
}

This new operation can be called in the same easy way:

// write the name of all the elements directly or indirectly contained by c
c.eachAllOwnedElement{ aNamedElement | stdio.writeln(aNamedElement.name) }

// collect all the elements directly or indirectly contained by c
var allownedElements : Sequence<Object> := Sequence<Object>.new
c.eachAllOwnedElement{ aNamedElement | allownedElements.add(aNamedElement) }