Add function types, anonymous functions and closures about wurstscript HOT 2 CLOSED

    public abstract class DamageCallBack
        abstract function onDamage(unit target, real damage)

    public function afterNextDamage(unit whichUnit, DamageCallBack d)
        List<DamageCallBack> l = getListforUnit(whichUnit)
        l.add(d)

    function damageSystemOnDamage(target, damage)
        let l = getListforUnit(target)
        for cb in l
            cb.onDamage(target, damage)
            destroy cb
        l.clear()


// Usage of the system without closures:
    // we would need to define a class like this:
    class MyDamageCallBack extends DamageCallBack
        real healAmount
        construct(real healAmount)
            this.healAmount = healAmount

        override function onDamage(unit target, real damage)
            target.addLife(healAmount)

    // and then use the system like this:
    let healAmount = ...
    afterNextDamage(target, new MyDamageCallBack(healAmount))


// Usage of the system with closures
    let healAmount = ...
    afterNextDamage(target, (target, damge) => target.addLife(healAmount))

// or alternative Syntax:
    afterNextDamage(target)
        function onDamage(unit target, real damage)
            target.addLife(healAmount))

class List<T>
    ...
    /** remove all elements which fulfill a predicate*/
    function removeAll(T => boolean filter)
        let it = iterator()
        while it.hasNext()
            let t = it.next()
            if filter(t)
                it.remove()


// Usage:
List<unit> someUnits = ...
real minHp = 100
// remove all units with less than minHp:
someUnits.removeAll(u => u.getLife() < minHp)

List<unit> someUnits = ...
real minHp = 100
// remove all units with less than minHp:
let it = iterator()
while it.hasNext()
    let t = it.next()
    if u.getLife() < minHp
        it.remove()

// Assume we are in some spell
vec2 velocity = ...
vec2 pos = ...
real time = 0.
// Now we could use a timer-closure to move a missile
// 'periodic' is a builtin construct
periodic(TIME_STEP)
    pos += velocity*TIME_STEP
    // and here we could do collision detection etc.

    if time > 10
        stop // stop is a builtin construct to stop periodic closures

unit target = ...
// damage the target after 1 second:
after(1.0)
    target.damage()