Lambdas in Java Preview. Часть 4. Обновление предложения

Это четвертая часть в серии постов в блоге (читай часть 1 , часть 2 и часть 3 ), в которой приводятся некоторые практические примеры лямбд, как может выглядеть функциональное программирование на Java и как лямбды могут влиять на некоторые из известных библиотек Java земельные участки. В этой части кратко описываются изменения нового предложения, которое было опубликовано во время написания этой серии, и как оно меняет некоторые примеры из этой серии.

Новое предложение На
прошлой неделе Брайан Гетц опубликовал новое предложениедобавить лямбда-выражения в Java, основанные на предыдущем предложении straw-man. Два самых больших изменения заключаются в том, что типы функций были удалены и что будет больше выводов типов, чем раньше. Также в новом предложении используется другой синтаксис для лямбда-выражений, но в нем также говорится, что это не отражает окончательное решение по синтаксису. Но давайте кратко рассмотрим каждый из этих пунктов.

Нет больше типов функций
Сначала это звучит раздражающе. Без типов функций, как мы могли бы передавать функции другим методам или функциям? Нам нужно как-то объявить их как параметры. Ответ заключается в том, что функции или лучшие лямбда-выражения должны быть преобразованы в типы SAM. Помните, что типы SAM являются отдельными типами абстрактных методов, такими как интерфейсы только с одним методом или абстрактные классы только с одним абстрактным методом, и что лямбда-выражения могут автоматически преобразовываться в такие типы. Это называется преобразованием SAM, которое я также обсуждал в первой части этой серии.

Таким образом, функциональные типы будут в первую очередь заменены преобразованием SAM, лямбда-выражения могут появляться только в тех местах, где они могут быть преобразованы в тип SAM. Я не до конца понимаю причины этого решения, но в некотором смысле оно действительно имеет смысл. Как кратко упомянуто в первой части этой серии, с точки зрения разработчика API вам больше не нужно ломать голову, если ваши методы должны принимать тип функции или тип SAM в качестве аргумента. И в любом случае типы SAM, вероятно, окажутся более гибкими.

Однако это изменит почти все примеры из этой серии. Во всех местах, где метод принимал функцию в качестве аргумента, тип этого аргумента должен быть изменен на тип SAM, и я почти везде использовал типы функций. Мы рассмотрим это позже и посмотрим, имеет ли смысл сейчас иметь некоторые универсальные интерфейсы функций для таких функций, как Function <X, Y>.

Больше выводов типов
Как мы также видели в примерах этой серии, лямбда-выражения могут быть довольно многословными из-за объявлений типов. Новое предложение гласит, что в основном все типы в лямбда-выражениях могут быть определены компилятором — их возвращаемые типы, типы параметров и типы исключений. Это сделает лямбды намного более читабельными.

Альтернативный синтаксис
Как уже говорилось, синтаксис нового предложения не отражает окончательное решение, но он гораздо больше похож на Scala или Groovy в этом предложении.

FileFilter ff = {file -> 
    file.getName().endsWith(".java") };

Хотя мне лично этот синтаксис стрелок нравится гораздо лучше, я буду придерживаться # -синтаксиса в этой серии, потому что его использует прототип.

Дополнительные изменения

Просто для полноты, предложение содержит еще несколько изменений. эта функция в лямбдах имеет семантику, отличную от предыдущей, в лямбдах нельзя использовать break и continue, и вместо return yield будет использоваться для возврата значений из лямбда-выражения (нет подробностей о том, как точно работает yield). Также будут ссылки на методы, которые позволяют ссылаться на методы существующего класса или экземпляра объекта.

Влияние на примеры

Теперь давайте посмотрим, как новое предложение меняет некоторые примеры предыдущих постов. Пример фильтрации файлов из первой части выглядел так:
Код клиента выглядел так:

public static File[] fileFilter(File dir, #boolean(File) matcher) {
    List<File> files = new ArrayList<File>();
    for (File f : dir.listFiles()) {
        if (matcher.(f)) files.add(f);
    }
    return files.toArray(new File[files.size()]);
}

File[] files = fileFilter(dir, #(File f)(f.getName().endsWith(".java")));

public static File[] fileFilter(File dir, FileFilter matcher) {
    List<File> files = new ArrayList<File>();
    for (File f : dir.listFiles()) {
        if (matcher.accept(f)) files.add(f);
    }
    return files.toArray(new File[files.size()]);
}

File[] files = dir.listFiles(#(File f)(f.getName().endsWith(".java")));

File[] files = fileFilter(dir, f -> { 
    f.getName().endsWith(".java") });

public <S> List<S> map(#S(T) f) {
    List<S> result = new ArrayList<S>();
    for (T e : this) {
        result.add(f.(e));        
    }    
    return result;
}

public interface Function1<X1,Y> {
    Y apply(X1 x1);
}

public <S> List<S> map(Function1<T,S> f) {
    List<S> result = new ArrayList<S>();
    for (T e : this) {
        result.add(f.apply(e));        
    }    
    return result;
}

List<Integer> list = new List<Integer>(2,4,2,5);
List<String> result = list.map1(n -> {"Hello World".substring(n)});

file.eachLine(#(String line) {
  System.out.println(line);
});

file.eachLine(line -> {
  System.out.println(line);
});

file.eachLine {
  System.out.println(it);
};