Я забавляюсь языком программирования, и его синтаксис находится под сильным влиянием Scala, в частности определений функций.
Я столкнулся с проблемой проектирования, потому что мой язык не различает функции, определенные с помощью def
синтаксиса (методы класса), и анонимные функции, назначенные значениям (созданные с использованием =>
) - он устраняет различия как в реализации, так и в поведении .
В результате два следующих определения означают одно и то же:
def square(x: Int) = x*x
val square = (x: Int) => x*x
Нет смысла использовать последнюю форму (немедленное анонимное назначение функции) в любой нормальной ситуации - ее просто можно использовать вместо def
формы.
Повлияет ли наличие такого дублирующего синтаксиса для определения именованных функций на ортогональность языка или какой-либо другой аспект дизайна?
Я предпочитаю это решение, потому что оно допускает короткие и интуитивно понятные определения методов и именованных функций (через def
), а также короткие определения анонимных функций (используя =>
).
Редактировать: Scala делает различие между двумя - анонимные функции не совпадают с методами, определенными def
в Scala. Различия относительно невелики - смотрите посты, на которые я ссылался ранее.
источник
However, assigning existing functions
кажется, отсутствует конец предложенияval
нотацию?fun
для определения рекурсивной функции.def
. Это просто побочный эффект того факта, что анонимная функция, скажем,(x : Int) => x + 1
является объектом, и объектам можно присвоить значения с помощьюval f = ...
. Разработчики языка должны были бы выйти из их пути , чтобы запретить синтаксис. Это не совсем то же самое, что явно приложить усилия для поддержки двух разных синтаксисов, которые делают (приблизительно) одно и то же.Ответы:
Я думаю, что наличие двух конструкций, которые означают одно и то же, но выглядят по-разному, должно быть сведено к минимуму в языке. Любое дублирование увеличивает сложность чтения (и, следовательно, написания / изменения кода) на вашем языке. Устранение всего дублирования неизбежно в языке, который может создавать произвольные конструкции (например, эквивалентность итерации против рекурсии).
Так что в этом случае, я думаю, это может быть разработано лучше здесь. Единственный способ определения функций имеет для меня самый смысл. В этом случае это звучит так, как будто два оператора scala, которые у вас есть, на самом деле имеют несколько разные значения, что, опять же, вероятно, не очень хороший дизайн (вероятно, лучше всего иметь что-то ясное, в котором говорится о различиях, например, ключевое слово).
Фактически, вы можете применить этот принцип не только к именованным функциям, но и к любой функции. Почему есть разница в определении именованных функций и анонимных функций? В Лиме , функции всегда определяются следующим образом:
fn[<arguments>: <statements>]
. Если вы хотите, чтобы быть « под названием» вы можете присвоить его переменной:var x = fn[<arguments: <statements>]
, и если вы хотите , чтобы передать его в другой функции анонимно:function[fn[<arguments: <statements>]]
. Если вы хотите, чтобы оно поднималось, сделайте его постояннымconst var x = fn[<arguments: <statements>]
. Одна форма делает очевидным, что они означают одно и то же.источник
const
вызывает подъем, но это имеет смысл. В JSfunction myFunc
вызывает подъем, ноvar myFunc =
это не так, что, возможно, немного менее интуитивно понятно, поскольку в противном случае они ведут себя примерно так же.function fnName()...
форма делает на самом деле создать константу, которая является то , что делает грузоподъемным действительную вещь , чтобы сделать с ним. Javascript делает вещи довольно запутанными, когда вы используете форму,var fn = function anotherFnName()...
так как это делает имяanotherFnName
не подъемным, даже если оно явно постоянное.То, что вы опубликовали, является действительным Scala и работает нормально.
Учитывая, что удвоение не вызвало проблем со scala (насколько мне известно), я скажу, что это не будет проблемой и для вашего языка.
источник
Я обнаружил фундаментальную разницу между лямбдами и
def
методами в Scala - я до сих пор не уверен, хочу ли я реализовать. Я должен провести дальнейшее исследование этого, и затем я сообщу о своем решении.По сути, только методы могут
return
- и когда ключевое слово используется из лямбда-выражения, оно фактически возвращается из охватывающего метода.Как я уже сказал, я не уверен, хочу ли я этого. Но это может быть достаточным оправданием для этого синтаксиса. Или, может быть, слишком опасно, потому что тонкие различия могут неожиданно причинить вред.
подробности
источник