Учитывая недавнее объявление Google об официальной поддержке Kotlin для разработки под Android, я подумал, что пора опросить сообщество, чтобы получить несколько удивительных советов по игре в гольф для этого относительно нового языка JVM.

Kotlin имеет уникальную комбинацию функций среди своих братьев и сестер JVM, что делает его потенциально привлекательным для игры в гольф:

• перегрузка оператора
• локальные , инфиксные и статические функции расширения
• умные броски
• Типовые безопасные строители Groovy-стиля
• псевдонимы типа
• диапазоны
• обширный пакет функциональных коллекций
• поддержка сценариев

Итак, как мне выжать последние несколько байтов из моей программы Kotlin? Один совет за ответ, пожалуйста.

Функции расширения

Функции расширения могут действительно помочь сократить имена встроенных методов и их цепочки, например:

fun String.c() = this.split("").groupingBy{it}.eachCount()

но это помогает, только если:

А) Звонок достаточно длинный, чтобы отменить определение

Б) звонок повторяется

Использование лямбд, а не методов

Lambdas может возвращаться без использования ключевого слова return, сохраняя байты

KotlinGolfer

Проект, который я начал здесь, который берет красивый код Kotlin и дает посты с тестами и ссылками TIO автоматически

Используйте +вместоtoString

Как и следовало ожидать, Stringперегрузка +оператора для конкатенации строк, например, так.

print("Hel" + "lo")

Однако проверка документов говорит нам, что она принимает Any?, а не только String. Как указано:

Возвращает строку, полученную путем конкатенации этой строки со строковым представлением данного другого объекта.

Другими словами, String + anythingубедитесь, что вы звоните .toString()с правой стороны перед объединением. Это позволяет нам сократить it.toString()до ""+it8% байтов в лучшем случае и 6 байтов в худшем.

Используйте foldвместоjoinToString

В связи с вышеизложенным, если вы звоните, mapа затем joinToString, вы можете сократить это, используя foldвместо этого.

list.map{it.repeat(3)}.joinToString("")
list.fold(""){a,v->a+v.repeat(3)}

Начиная с версии 1.3, вы можете полностью опустить аргументы в функции fun main () , тем самым сбривая 18 символов (то есть длину args:Array<String>).

Определение Int в параметрах

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

Пример из моего ответа на этот вопрос:

определение переменной в функции:

fun String.j()={var b=count{'-'==it}/2;var a=count{'/'==it};listOf(count{'o'==it}-a,a-b,b)}

определение переменных в качестве параметров:

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

потому что var a=это та же длина, что и для a:Int=их определения будет то же количество байтов (это только для случая Int), так как теперь у меня есть только 1 строка в функции, я могу удалить {}и также удалить одну ;(другой заменено на ,)

Поэтому, если есть какие-либо функции, требующие определения Int, и они будут равны 1, если вы не определили int в функции - тогда выполнение этого в качестве параметра сэкономит пару байтов.

toИнфиксной

Существует стандартная инфиксная функция с именем, toкоторая создает Pairs из двух значений. Обычно используется mapOf()для определения Maps, но потенциально может быть намного короче, чем Pair()конструктор.

Pair(foo,bar)   //constructor
foo to bar      //best case 
(foo)to(bar)
((foo)to(bar))  //worst case

Разрушение в лямбда-аргументах

Скажем, вы хотите принять Pair<*,*>лямбду. Обычно, обработка этого была бы раздражающей. В качестве примера, вот лямбда, которая принимает Pairи проверяет, равны ли два значения:

{it.first==it.second}

Это многословно и неуклюже. К счастью, Kotlin позволяет вам деструктурировать любой разрушаемый тип (любой тип, который реализует componentN()методы, такие как Pairи Tripleт. Д.) Как аргументы лямбда-выражения. Итак, мы можем переписать это следующим образом:

{(a,b)->a==b}

Это похоже на сопоставление с образцом кортежа в чем-то вроде F #, и это во многих случаях. Но широкий спектр типов в Kotlin поддерживает деструктуризацию ( MatchResultэто полезно.)

Вы можете принять больше аргументов, хотя. Скажем, ваша лямбда должна была принять Pairи дополнительное значение. Вы просто напишите лямбда-сигнатуру так:

(a,b),c->  // pair first
a,(b,c)->  // pair second