Лучше использовать "и" или "в" при цепочке "отпускать" заявления?

Я понимаю, что это, наверное, глупый вопрос, но...

Если я свяжу кучу операторов let, которые not должны знать друг друга, лучше использовать and или in?

Например, какой из них предпочтительнее, если таковой имеется:

let a = "foo"
and b = "bar"
and c = "baz"
in
  (* etc. *)

или

let a = "foo" in
let b = "bar" in
let c = "baz"
in
  (* etc. *)

Моя интуиция подсказывает мне, что первая должна быть "лучше" (по очень мелкому определению "лучше" ), потому что она создает минимальное количество областей, необходимых, в то время как последнее является областью видимости в пределах области видимости -a-scope, который компилятор/интерпретатор позаботится о том, чтобы отметить, но в конечном счете неважен и бесполезен.

Ответы

Ответ 1

Ответ на вопрос "что лучше?" только действительно имеет смысл, когда интерпретации не отличаются. Семейство языков ML (по крайней мере, SML и OCaml) имеет как параллельную форму инициализации (and), так и последовательную, по существу, вложенную область (in), потому что они полезны в определенных ситуациях.

В вашем случае семантика одинакова, так что вам остается ответить на вопрос "что вам лучше всего читать?" и, может быть, (если это не преждевременно), "которые могут быть выполнены более эффективно?" В вашем случае альтернативы:

  • Для случая and: оцените связку строк и выполните параллельную привязку к трем идентификаторам.

  • Для случая in: bind foo - a, затем привяжите bar к b, затем привяжите baz к c.

Что читается лучше? В этом случае это подбрасывается, потому что результат не имеет значения. Вы можете опросить некоторых англоговорящих, но я сомневаюсь, что будет много предпочтений. Возможно, большинству понравится and, поскольку он разделяет привязки, оставляя единственную in перед выражением.

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

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

Нижняя строка: в этом случае это истинная броска; просто убедитесь, что правильно использовать параллельное или последовательное, когда результат имеет значение.

Ответ 2

Мое мнение таково, что in лучше. Использование and подразумевает, что определения взаимно зависят друг от друга. Я думаю, что лучше понять, что это не так. С другой стороны, некоторые программисты OCaml предпочитают and для очень коротких определений, где немного более компактная нотация может выглядеть чище. Это особенно верно, если вы можете поместить определения в одну строку:

let a = "foo" and b = "bar" in

Ответ 3

Это то же самое, что разница между let и let* в Lisp, я считаю. let* (аналогично по функциональности структуре in..in.. - вторая структура в вашем вопросе) иногда используется, чтобы скрыть императивное программирование, поскольку оно гарантирует последовательное выполнение выражений (см. то, что Пол Грэм должен был сказать о let * in Вкл. Lisp).

Итак, я бы сказал, что прежняя конструкция лучше. Но, правда, я думаю, что последнее чаще встречается в программах Ocaml, которые я видел. Вероятно, просто проще использовать, позволяя строить на ранее названных выражениях.

Ответ 4

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