Oracle ввел замыкания в Java7

ну эт еще ниче, непонятно только зачем : после [ (или перед x — как правильно читать?) и зачем слово value?

было б лучше так:

i1 := [3].
i2 := [x | x + 1] 3.

>или перед x — как правильно читать?

Да, : ставится перед каждым параметром лямбды

и зачем слово value?

value - это сигнал, который шлётся лямбде чтобы собственно выполнить её код.

Если без value, мы бы в обоих случаях получили бы объекты класса BlockClosure (которым потом могли бы послать value)

>Списки у них разные и т.д.

Есть scala.collections.jcl с полным набором неявных преобразований. С этим добром всё намного симпатичнее.

В посте нет ни одного замыкания, по ссылке тоже обычные быдлолямбды. Беглый парсинг тесткейсов замыканий также не выявил.

Итого: утка.

Потому что я лично использовал слово lambda как название переменной когда то. Так же это делали тысячи других разработчиков. Весь этот код с подобным нововведением перестанет компилироваться. Такое разработчики Java не станут делать.

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

P.S. судя по тому черновику, в jdk7 должны были появиться новые классы и интерфейсы для поддержки замыканий. Были ли? или просто сахар вокруг inner class?

А ты попробуй подумать, чем оно было вызвано

Зачем мне думать, чем оно было вызвано, если известен тупейший workaround - final массив из одного элемента (аналог указателя). Почему компилятор не может все не read-only захватываемые локальные переменные положить в кучу и обращаться к ним через указатель - я не знаю. Наверное тем, кто придумал это ограничение, было лень.

а в чём смысл замыканий? вот например такое #(int x)(x+=2); - это натипа функция которая может быть в методе? и как к ней обращаться?

К примеру мы хотим написать функцию сортировки массива неких объектов. Чтобы сортировать, нам нужно знать, какой объект больше другого. Сейчас это делается примерно так:

interface Comparator<T> {
    int compare(T obj1, T obj2);
}

<T> void sort(T[] arr, Comparator<T> comparator) { ... }

Integer[] x;
...
// отсортировать по убыванию
sort(x, new Comparator() {
    @Override
    int compare(Integer i1, Integer i2) {
        return i2 - i1;
    }
});

С этим нововведением можно будет упростить код примерно до такого:

sort(x, #(Integer i1, Integer i2) (i2 - i1));

Кроме этого есть ещё много полезных применений.

Замыкания ненужны.

> P.S. предлагаю банить тех, кто не оформляет ссылки надлежащим образом.

Банить - наверное слишком круто, но за оформления кода без [code] нужно снимать скор, однозначно.

> Замыкания сами по себе уебищны.

Именно!

Ерунда какая-то, замыкания реализовывали при помощи анонимных классов (таки да, семантика хромает), зачем еще один костыль вводить?

А что такое «функция», как не метод класса?

а что такое метод класса, как не функция с нестандартной последовательностью записи аргументов?

Из всех возможный вариантов синтаксиса оракел выбрал самый убогий, ч и следовало ожидать

Шёл 2010...

Мне куда больше нравится такой синтаксис в шарпе:

Func<int, int> f1 = x => x + 1;
Func<int, int, int> f2 = (x, y) => x + y;

var list = new[]{ 2, 5, 8 };
Func<int> f3 = () => 
   {
      int sum = 0;
      foreach (int i in list) sum += i;
      return sum;
   };

int r1 = f1(5); // 6
int r2 = f2(3, 4); // 7
int r3 = f3(); // 15

Int -> Int

P.S. предлагаю банить тех, кто не оформляет ссылки надлежащим образом

В Опере- выделить ссылку, нажать правую кнопку, «перейти по адресу»

Т.е. это скрыта реклама оперы? Тогда тем более банить.

int compare(Integer i1, Integer i2) { 
        return i2 - i1; 
    } 

Очень интересный и оригинальный способ сравнения целых чисел. Работающий в режиме 24/7.

Func<int, int> f1 = x => x + 1;

а без явного указания типов работает?

Func<int, int> f1 = x => x + 1;

а без явного указания типов работает?

Нет, вот так сделать нельзя

var f1 = x => x + 1;

Можно сделать так

delegate int F(int x);

....

F f1 = x => x + 1;

не откуда вывести тип для x

полиморфный тип - можно:

*Corec> :t (\x -> x + 1)
(\x -> x + 1) :: (Num a) => a -> a

иными словами, подходит любой тип, над которым выполнимы арифметические операции

конкретный будет выведен в точке применения:

*Corec> :t (\x -> x + 1) (1 :: Int)
(\x -> x + 1) (1 :: Int) :: Int
*Corec> :t (\x -> x + 1) (1 :: Double)
(\x -> x + 1) (1 :: Double) :: Double

но, боюсь, система типов C# этого не позволит

полиморфный тип - можно:

Я думал, мы о C# говорим.

Я думал, мы о C# говорим.

прежде всего - о замыканиях. в частности, об их реализации в C#

я всего лишь указываю на то, что фраза неоткуда вывести тип несколько, гм, ошибочна; причина необходимости явного указания типов - иная

прежде всего - о замыканиях. в частности, об их реализации в C#

Нет, мы говорили о C#, т.к. я привёл код на C#, а ты спросил "а без явного указания типов работает?". Я сказал, что не работает и объяснил, почему.

я всего лишь указываю на то, что фраза неоткуда вывести тип несколько, гм, ошибочна

Нет, не ошибочна. Я прав. Из этого кода нельзя определить тип x:

var f1 = x => x + 1;

причина необходимости явного указания типов - иная

Нет иных причин.

Нет, мы говорили о C#

Нет, не ошибочна. Я прав

Нет иных причин

ты идиот. сферический

ты идиот. сферический

Спасибо, что признал мою правоту.

Спасибо, что признал мою правоту.

всегда пожалуйста. обращайся ещё

> #()(3).(); #()(3).() #(int x)( x + 1 ).(3);

приятный глазу круглые скобочки. Не то, что уродливые '{ и '}

без явного указания типов работает?

Кстати, в f# без явного указания выведется int. Не знаю, когда введут классы типов...

> let f1 x = x + 1;;

val f1 : int -> int

Да и, вообще, что-то громоздко получилось в c#. Вот f#.

> let f1 x = x + 1
  let f2 x y = x + y
  let f3 () = [2; 5; 8] |> List.sum

  let r1 = f1 5
  let r2 = f2 3 4
  let r3 = f3 ()
  ;;

// это вывод REPL
val f1 : int -> int
val f2 : int -> int -> int
val f3 : unit -> int
val r1 : int = 6
val r2 : int = 7
val r3 : int = 15

>потому что не откуда вывести тип для x.

Потому что C# так не умеет. Тип можно было бы вывести из последующего использования, например, под .Net Nemerle так и делает.

> В посте нет ни одного замыкания

Именно. Заметил сразу, но ждал, пока хаскелисперы спустят всех собак. ))
Они какие-то слишком пассивные нынче, совсем не торт. ))

> расскажи честному народу, чем анонимный класс отличается от замыкания?

Замыкания - это в первую очередь захват переменных/значений из внешней области видимости. Иначе это просто унылое определение анонимной функции.

совсем не торт

надоело

>> расскажи честному народу, чем анонимный класс отличается от замыкания?

Замыкания - это в первую очередь захват переменных/значений из внешней области видимости.

В анонимных классах это есть. Отличия называй.

При наличии возможности перегрузки оператора +, в самом деле, вывести тип совершенно неоткуда. Тебе по делу возразили, а ты со своим не относящимся вообще к теме какацкелем вылез. Функциональщики такие смешные фанатики, это что-то с чем-то!

Тип можно было бы вывести из последующего использования, например, под .Net Nemerle так и делает.

Только для внутренних def. Внешних функций нет, а есть методы, сигнатуры которых надо объявлять в обязательном порядке.

[вброс] Тут хаскель, конечно, крут. И с ним никто из других известных не сравниться. [выброс]

> Замыкания - это в первую очередь захват переменных/значений из внешней области видимости.

Анонимный класс ведет себя так же, и совершенно зря. Одно дело просто объявление класса без имени, и совсем другое - класс с неявно заданными полями. Это неоправданное и ненужное усложнение семантики языка, провоцирующее людей на написание write only говнокода. Суйте это барахло в свои лиспы и перлы, сколько влезет, но не трогайте Java, этот язык сделан для простого, умного, прозрачного кода, который легко читать и поддерживать.

> Тип можно было бы вывести из последующего использования, например, под .Net Nemerle так и делает.

Нельзя. Нет у тебя всего последующего использования ни в какой момент, даже когда уже JIT работает.

Можно было бы как с generics, специализировать в каждом конкретном применении, но для этого потребовалось бы где-то исходник хранить, и вообще это сильно противоречит идее раздельной компиляции и поздней линковки. Шибко много сложностей ради сомнительного удовольствия не писать явно типы аргументов.

Откуда столько шума? Если добавить inline в определение функции на f#, то компилятор выведет абстрактный тип, у которого должен быть определен статический метод (+) от двух аргументов. Почти класс типов как в хаскеле. То есть, и в мейнстриме теперь такое частично есть :)

А c# убог, как и ява. Их виртуальные машины - нет.

>> P.S. предлагаю банить тех, кто не оформляет ссылки надлежащим образом

В Опере- выделить ссылку, нажать правую кнопку, «перейти по адресу»

Операстов тоже банить - за непомерное ЧСВ.

> В анонимных классах это есть.

In Java's anonymous inner classes only references to final members of the lexical scope are allowed

Говорит нам википедия. http://en.wikipedia.org/wiki/Comparison_of_Java_and_C_Sharp

Или я что-то проспал и анонимный класс в яве может захватывать _переменные_ ?

Пургу понес. Умеет Немерле, но в очень ограниченных случаях.

> Анонимный класс ведет себя так же

http://www.linux.org.ru/jump-message.jsp?msgid=4958030&cid=4962398

совсем другое - класс с неявно заданными полями. Это неоправданное и ненужное усложнение семантики языка

Кто ж спорит то? Идея абсолютно дурацкая. Тем более, если это не замыкания, а всего лишь онанимные функции. )))

> При наличии возможности перегрузки оператора +, в самом деле, вывести тип совершенно неоткуда.

Ты уверен?

> In Java's anonymous inner classes only references to final members of the lexical scope are allowed

Говорит нам википедия

Правильно говорит. И что? Доступ к локальным переменным есть? Да. Значит, это замыкание.

Абсолютно. В системе типов .NET нет понятия «общий тип, у которого есть метод 'operator+'».