1. Kotlin / Говнокод #27548

    −1

    1. 1
    val cityEq: (City) -> (Customer) -> Boolean = { city -> { it.city == city } }

    Какой Kotlin ^_^^_^^_^

    Запостил: PolinaAksenova, 04 Августа 2021

    Комментарии (25) RSS

    • От сахара някнуться можня ☆*:.。.o(≧▽≦)o.。.:*☆.
      Ответить
    • City -> Customer -> Boolean

      Ого, прям как в функциональщине всякой.

      А откуда берутся city и it? Нигде же не написаны имена аргументов.
      Ответить
      • city — параметр внешней лямбды (тип city выведен из типа cityEq), it — няявный аргумент для лямбды с одним параметром. Примерный перевод:
        auto cityEq = [](City & city) {
            return [](Customer & it) {
                return it.city == city;
            };
        };


        А, в "{ city -> ...}" "city" — это как раз имя параметра.
        Ответить
        • Магия какая-то... Он что, первую попавшуюся переменную в лямбде считает ее аргументом?
          Ответить
          • А тьфу, поняла.

            Во внешней лямбде меньше сахара, там { city -> f(city) }.

            А вот во внутренней уже и имя переменной опустили, поэтому там it. Т.е. там { it -> it.city == city } если полностью расписать.
            Ответить
            • Да, перед стрелочкой в лямбде идёт объявление её параметров:
              val lamblia_1 = { x: Int, y: Int -> x + y }  // Типы и нязвания параметров заданы явня
              val lamblia_2: (Int, Int) -> Int = { x, y -> x + y }  // Нязвания параметров заданы явня, типы выведены из
                                                                    // типа переменной, которой присваивается лямбда
              val lamblia_3: (Int) -> Int = { it * 2 }  // Тип параметра выведен няявня, имя тоже

              Когда лямбда присваивается переменной с явня заданным типом — Котлин изо всех сил пытается вывести типы параметров лямбд автоматически.
              Ответить
    • А Customer не обидится, что к нему через местоимение it обращаются?
      Ответить
    • inline fun myMap(lst: List<Int>, lamblia: (Int) -> Int): List<Int> =
          lst.map(lamblia)  // няважня
      
      fun main(args: Array<String>) {
          // Уровни безумия сахара
          val lst = listOf(1, 2, 3)
          println(lst.joinToString(", "))
          
          // 0. Нулевой: анонимная функция.
          val lst_func = myMap(lst, fun(x: Int): Int { return x * 2 })
          
          // 1. Базовый. Объявляем всё явня.
          val lst_explicit = myMap(lst, { x: Int -> x * 2 })
      
          // 2. Даём Котлиняше вывести тип параметра.
          val lst_x_infer = myMap(lst, { x -> x * 2 })
      
          // 3. Используем няявный параметр it с выведенным типом.
          val lst_implicit_single_param = myMap(lst, { it * 2 })
      
          // 4. Выносим лямбду за скобочки!
          val lst_out = myMap(lst) { it * 2 }
      
          println(lst_explicit.joinToString(", "))
          println(lst_x_infer.joinToString(", "))
          println(lst_implicit_single_param.joinToString(", "))
          println(lst_out.joinToString(", "))
      }
      Ответить
      • > myMap(lst) { it * 2}

        Какое руби )))
        Ответить
      • Это какие-то анафорические лямды что ли?
        Ответить
        • Так точня ( ̄^ ̄ゞ!
          Тип лямбды зависит от типа переменной, которой эта лямбда присваивается.
          Ответить
      • >> // 4. Выносим лямбду за скобочки!

        Каррирование, частное применение?
        Ответить
        • s/частное/частичное/

          Какая невнимательность )))
          Ответить
          • Может, просто дубовая рубишня, когда благодаря синтаксиальной психозе аргументы просто так записываются и "myMap(lst)" либо не компилируется, либо срабатывает как вызов с пустошнёй во втором аргументе?
            Ответить
        • Нят, нястоящей функционяльщины котлиняши ня осилили, а это просто синтаксический сахар: если последний параметр в функции имеет функционяльный тип, то лямбду туда можня передавать за скобочками (а если параметр всего один — то скобочки вообще можня опустить: "val x = listOf(1, 2, 3).map { it * 2 }").
          Ответить
          • Жаль. А такой красивый косплей функционяльщины!
            Ответить
          • Эту фишку про "блоки" вроде из руби упёрли. Только там они реально блоками были, а не лямбдами. Можно было return сделать, к примеру.
            Ответить
    • А зачем оборачивать типы аргументов в скобки?
      Я ещё понимаю, зачем писать (a -> b) -> c и зачем начинающий писал бы a -> (b -> c). Но (a) -> (b) -> c. Зачем? Зачем?
      Ответить
      • Синтаксическая соль.
        Ответить
      • Чтобы ня усложнять грамматику, видимо. В отличие от "C++", в Котлине оня есть: https://kotlinlang.org/docs/reference/grammar.html#functionType .
        Ответить

    Добавить комментарий