Убрать запрет на expression body в общем случае

[PilotOfSparrow]

Чтобы можно было так:

    private fun moo(mo: String) = when (mo) {
        "you",
        "and",
        "me" -> true
        else -> false
    }

    private fun foo() =
        try {
            if ("ohhh" == "you touch my talalam") {
                throw IllegalStateException("It's din din dong")
            }
            "magic"
        } catch (e: Exception) {
            println("ta talala talalalala")

            "the gathering"
        }

Сейчас можно только так:

    private fun moo(mo: String): Any {
        return when (mo) {
            "you",
            "and",
            "me" -> true
            else -> false
        }
    }

    private fun foo(): String {
        return try {
            if ("ohhh" == "you touch my talalam") {
                throw IllegalStateException("It's din din dong")
            }
            "magic"
        } catch (e: Exception) {
            println("ta talala talalalala")

            "the gathering"
        }
    }

[osipxd]

Возможно, вкусовщина, но я бы использовал expression body только в случаях когда у функции "одно тело", то есть when, with, repeat и т.д. а для if ... else, try ... catch использовал бы block body.

Первый вариант для меня выглядит более читаемо и по краткости не уступает:

fun blockFoo() {
    if (...) {
        // ...
    } else {
        // ...
    }
}


fun expressionFoo() =
    if (...) {
        // ...
    } else {
        // ...
    }

[xd720p]

Я бы добавил ещё чтобы можно было реактивные цепочки писать через expression body - вполне читаемо и уже привычно для многих

Ну и раз when через expression body, то и if-else тоже через него - в обоих случаях ветвление и возврат результата, к тому же expression body позволит писать однострочные if-else для коротких, но часто используемых функций

[mrblrrd]

Я за разрешение expression body в полной мере.

Куда важнее на мой взгляд, чтобы группа методов в одном файле была оформлена в едином стиле для простоты восприятия, а не expression body vs. block body.

[Jeevuz]

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

Без жёсткого правила, всегда будут появляться такие варианты:

    private fun moo(mo: String) = 
        when (mo) {
            "you",
            "and",
            "me" -> true
            else -> false
        }
    // Нет закрывающей скобки уровня функции.

    fun chain() = some
        .call()
        .another()
        .andOneMore()

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

К тому же это дополнительный геммор дергать замену на блок бади когда вдруг нужно ещё что-то сделать, чт от не может быть в экспрешне.

Для меня, использовать почти всегда блок бади - это однотипность.

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

[osipxd]

@Jeevuz, а как насчёт варианта когда expression не переносится? Например when или with:

// Когда функция содержит только when
fun handleEvent(event: Event) = when(event) {
    is ShowMessage -> showMessage(event.message)
    is ShowError -> showError(event.error)
}

// Или если она конфигурирует что-то
fun initUi() = with(binding) {
    saveButton.setOnClickListener { viewModel.onSaveClicked() }
    // ...
}

В этом случае:

1. Всё еще явно видно где заканчивается функция
2. На один уровень вложенности меньше

[Jeevuz]

@osipxd Да, этот вариант хороший, мне он нравится. Все равно видно конец тела функции. Главное, чтобы это четко соблюдалось.

И плюс возникает вопрос тогда что с этим делать, разрешать или нет:

fun initText() = binding.content.textView.apply {
    saveButton.setOnClickListener { viewModel.onSaveClicked() }
    // ...
}

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

fun initText() = binding
    .content
    .textView
    .apply {
        saveButton.setOnClickListener { viewModel.onSaveClicked() }
        // ...
    }

И придется переделывать в блок. А лишние телодвижения из-за стайлгайда - ну такое..

[Jeevuz]

Есть предложение сойтись на таком:

fun singleLine() = just.single().line().ofCode().isPerfectlyOk 

fun singleHigherOrderFunctionWithLambda() = higherOrderFunctionWithLambda(params) { 
  ...
} 

fun singleExpressionWithCurlyBrackets() = when(something) { 
  ...
} 

То есть:

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

[osipxd]

Можно ещё добавить в качестве предостережения, что если выражение используемое с функцией со скобками сложное, стоит использовать функцию с блоком (Как-то коряво сформулировал)
Хочется избежать подобного:

val someFun() = when(getNumberForType(arg.mapToUi().type)) {
    0 -> ...
    1 -> ...
    else -> ...
}

[Jeevuz]

Ну кстати это не кажется сложночитаемым. Скорее просто не красиво :) Тут бы это вынести в параметр и сетить снаружи. Имхо, можно это не ограничивать. Но добавить, что открывающая скобка должна оставаться на одной строке с fun, тогда длина строки ограничит такие штуки.

[osipxd]

Да, норм

[mrblrrd]

Предлагаю не маскирвоать expression body под block body и преимущественно всегда делать перенос после равно =. Кроме случаев, когда помещается в одну строку. Расскажите, почему вы хотите, чтобы fun был на одном уровне с }, чтобы выглядело как будто это block body?

[Jeevuz]

Да, чтобы мимикрировать.
Основной поинт - наличие закрывающей скобки на уровне с fun. Если перенести после =, то закрывающая будет сдвинута и тяжелее читать. Тогда уж лучше блок бади делать всегда.

Просто почему неудобно выше писал, вот #7 (comment)

[mrblrrd]

Я неоднозначено вопрос сформулировал. Мне интересно, почему мимикрировать – это хорошо? Только потому что «читать легче», или есть какие-то еще причины?

На мой взгляд плохо, когда две разные по смыслу конструкции пытаются выглядеть одинаково. Цель использования expression body – подчеркнуть, что функция возвращает значение определенного типа. Block body – шире, функция может не возвращать значение, а делать какой-то сайд эффект. Это смысловое разделение дает читающему больше информации: что от функции ожидать и как ее анализировать. Если их форматировать по-разному, то легче будет понять какого вида функция и, соответственно, намерение разработчика. Если мы будем пытаться форматировать их одинаково, то мы затрудним отделение одного от другого, надо будет вчитываться. С этой точки зрения читать наоборот будет труднее.

В общем, предлагаю сначала определить принцип формирования код стайла. Он нам в первую очередь для того, чтобы при чтении кода быстрее усваивать намерение и смысл, и только во вторую очередь эстетика? Или наоборот? Если мы с этим принципом не определимся, то мы будем часто скатываться в обсуждение эстетических предпочтений, которые у каждого свои.

[osipxd]

Для меня причина мимикрии как раз смысловая. Закрывающая скобка на уровне fun подчёркивает, что это функция, а не свойство.
Например такие конструкции выглядят почти одинаково:

val lastState: State
    get() = {
        // ...
    }

fun renderState(state: State)
    = with(binding) {
        // ...
    }

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

С точки зрения смысла лучше всегда использовать block-body, а использование expression-body это отхождение от смысла ради красоты и уменьшения визуальной вложенности. На мой взгляд приемлемо только в случае когда выражение, которое оказывается на одной строчке с объявлением функции, не содержит логики и его можно "вынести за скобки" и не обращать на него внимание при чтении тела функции. Отличный пример, как раз использование with(binding):

fun render(state: State) {
    return with(binfing) {
        // ...
    }
}

fun render(state: State) = with(binding) {
    // ...
}