• A closure isn't neccessarily anonymous.
• An anonymous function doesn't neccessarily capture the lexicial environment

Closures are a very powerful feature, but dangerously so. They are arguably too easily abused. A language designer has the responsibility to force a programmer to be explicit about dangerous things.

function scale_list(list, scale_factor){
  return map(list, function(e){return e * scale_factor}
}

function foo(a){
  b = a * 2;
  return bar(function(i){i + b})
}

function scale_list(list, scale_factor){
  newlist = []
  for(e in list){
    newlist.append(e * scale_factor)
  }
  return newlist
}

scale_list = [*] curry map
 
example:
 
{1,2,3} 2 scale_list =>
{1,2,3} 2 [*] curry map =>
{1,2,3} [2 *] map =>
{2,4,6}

public class Test
{
    public static void main(String args[])
    {
        
    }
 
    List scaleList(List<Integer> in, final int scale_factor)
    {
        return Functional.map(in, new Function<Integer, Integer>() {
            public Integer exec(Integer i) { return i * scale_factor; }});
    }
}
 
interface Function<E,V>
{
    V exec(E in);
}
 
class Functional
{
    public static <E,V> List<V> map(List<E> list, Function<E, V> f)
    {
        List<V> out = new ArrayList<V>();
 
        for (E item : list) {
            out.add(f.exec(item));
        }
 
        return out;
    }
}

textField.addActionListner( new ActionListener() {
    public void actionPerformed( ActionEvent notUsed ) {
        textArea.append( textField.getText() );
    }
});

textField.addActionListner( ActionListener() ( notUsed ) textArea.append( textField.getText() ); );

List scaleList(List<Integer> in, final int scale_factor)
    {
        return Functional.map(in, new Function<Integer, Integer>() {
            public Integer exec(Integer i) { return i * scale_factor; }});
    }
 
interface Function<E,V>
{
    V exec(E in);
}

FList scaleList( final FList<Integer> in, final int scale_factor ) {
    return in.map( new F<Integer, Integer>() {
        public Integer e( final Integer i ) {
            return i * scale_factor; 
        }
    } );
}

FList scaleList( final FList<Integer> in, final int scale_factor )
    return in.map( F<Integer, Integer>() ( final i )
        return i * scale_factor; 
    );