Как вы можете определить, является ли язык «динамическим языком»?

2

Я пытаюсь лучше понять, что на самом деле означает, что язык будет "динамическим". У меня довольно большой опыт работы с Lingo, который является языком сценариев для линейки продуктов Adobe (ранее Macromedia) Director, и мне просто интересно, будет ли он рассматриваться как "динамический язык".

Перемещение переменных и списков выглядит очень "динамическим языком" - для меня.

С переменными вы просто напишете foo = 3 или bar = "Hello World". Вы не объявляете переменную как int или string - она ​​показывает, что это не так.

Со списками вы можете просто написать что-то вроде miscCollection = [3, "Hello World", #helloWorld, ["Embedded List", "Goes Here", 3], [#phrase: "Property List goes here", #value: 3]]. Не будет ли это похоже на a tuple?

Являются ли эти возможности достаточными для получения статуса "динамического языка"?

Интересно, что я использую С# намного больше, а Director/Lingo - намного меньше, но со всеми волнениями по динамическим языкам в эти дни, я задаюсь вопросом, действительно ли я против против зерна.

ИЗМЕНИТЬ

В отношении ответа Марка Рушакова ниже, здесь, попытка проанализировать, может ли Lingo квалифицироваться как "динамический", используя эту статью в Википедии:

  • Eval - Lingo имеет ключевые слова do и value. do выполнит всю команду, например, do "foo = 23" или do "foo = sum(20, 3)". value пытается преобразовать строку в числовую, но это больше, чем просто оператор синтаксического анализа - он может фактически преобразовать строковое представление переменной в ее число, например, если предположить foo = 23, утверждение value("foo") будет оценить до 23.

  • Функции более высокого порядка. Если я понимаю это право, это в основном то, что я бы назвал "делегатом" на С#. Насколько я знаю, Lingo не поддерживает это напрямую, хотя вы можете создать тип (называемый "родительский script" ), который имеет функцию и передает экземпляр типа.

  • Закрытие - не знаю, насколько это известно.

  • Продолжение. Никакой поддержки для этого, насколько мне известно.

  • Отражение. В некотором смысле, да. Фактически вы создаете новые экземпляры типов с использованием строки, например, fooInstance = script("Foo").new(bar). Также возможно преобразовать экземпляр типа в строку, содержащую имя типа (так что вы можете сортировать функцию mimic С# GetType()). Вы также можете запрашивать свойства типа, не зная имена свойств (например, искать свойство по индексу) и узнавать имена свойств по индексу.

  • Макросы. Как статья в Википедии описывает макрос, я так не верю. Однако можно редактировать скрипты во время выполнения, поэтому, возможно, это считается.

Итак, похоже, что Lingo набирает от 2 до 3 из 6 динамических функций, но я недостаточно ясно о закрытии и продолжениях, чтобы точно знать, что Lingo их не поддерживает. Наверное, я не уверен, что делать. Комментарии приветствуются.

  • 0
    Похоже, JavaScript для меня.
  • 2
    Определение, которое вы используете, кажется очень противоречивым. Непонятно, почему лямбды / замыкания должны иметь какое-либо отношение к «динамическому языку», например. Похоже, что eval - единственное значимое определение. Конечно, есть и «динамически типизированный», и я не уверен, что ваш «динамический» должен быть одним и тем же или совершенно другим понятием.
Показать ещё 6 комментариев
Теги:
dynamic
dynamic-languages
esoteric-languages
lingo

4 ответа

2
Лучший ответ

"динамический" - одно из тех слов, которое модно, но на самом деле означает немного больше, чем "Что я делаю, это круто"... у него нет точного определения.

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

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

Это две крайности. Как и все в жизни, на практике языки лежат где-то между двумя теоретическими крайностями. Поэтому иногда трудно сказать, что язык напечатан или неттип - часто все, что вы можете сказать, это что-то вроде "язык X имеет лучшую проверку типов во время компиляции, чем язык Y, потому что эти ошибки попадают в X, но не в Y:...."

Учитывая это определение, вы можете опасаться, что (1) типизированный язык требует гораздо больше текста в программе (потому что вам нужно сказать, какое значение имеет каждое значение) и (2), что типизированный язык может ограничивать то, что вы можете сделать без необходимости (потому что система типов недостаточно умна, чтобы разрешить что-то, что вы можете видеть).

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

String s = "hello"

когда это очевидно с помощью только

s = "hello"

что "s" должно быть строкой? Языки, которые "умны", как это, и где вам не нужно говорить, что все типы, но они все еще проверяются, часто называются "Хиндли Милнер", потому что это люди, которые сначала разработали, как это сделать в деталях.

Итак, когда вы смотрите на программу, написанную для языка с системой типа Hindley Milner, может показаться, что у нее нет типов. Но это ошибка. Перед выполнением программы все еще будет работать, какие должны быть все типы всех переменных, и убедитесь, что вы не можете получить никаких ошибок для попытки сделать что-то с неправильным типом (я думаю, это потрясающе - это близко к своего рода искусственный интеллект...)

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

Изменить: Я просто перечитал выше, и я мог бы быть немного понятнее. Различие, которое я пытался сделать, было между языками, которые имеют тип system, и языки, которые этого не делают. Система типов включает в себя две вещи: типы сами и логику, чтобы проверить правильность типов.

Языки, которые я называл "нетипизированными" (или динамически типизированными), имеют типы. Например, в Python (который является нетипизированным динамическим языком) все еще существует разница между строкой и целым. Но у них нет дополнительной логики, которая проверяет программу до ее запуска. Поэтому было бы более точно сказать, что они имеют типы, но не имеют системы типов.

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

  • 1
    -1 - называть динамически типизированный язык «нетипизированным» - это вопиющее злоупотребление принятой терминологией. То, что вы называете «типизированным» языком, является «статически типизированным» языком. en.wikipedia.org/wiki/...
5

Вывод типа (например, ваши примеры foo = 3 и bar = "Hello World") не подразумевает динамический язык. Ключевое слово var в С# указывает тип переменной во время компиляции, а Haskell также может использовать неявное типирование для всех переменных, даже в скомпилированных программах.

"Динамический язык программирования" - это довольно неопределенный термин, но я думаю, что если бы вам пришлось ограничивать его одним квалификатором, быть отражением во времени. Если вы можете сделать отражение, вы можете, возможно, сделать другие квалификаторы, перечисленные в статье Википедии (eval, изменение времени выполнения объекта, закрытие, макросы...).

Я ничего не знаю о языке Lingo, но я бы сказал, что вообще легче дисквалифицировать язык как динамический, чем квалифицировать язык. Может ли Lingo делать какие-либо/все отборочные в статье в Википедии? Если нет, то это, вероятно, просто не динамично. Если он может сделать любой, то он, вероятно, по крайней мере "достаточно динамический".

1

Когда люди говорят о том, что язык программирования является "динамическим", обычно они относятся к системе динамического типа. Лучшее определение того, что такое система динамического типа (и что это не так), которую я когда-либо читал, - это отличная статья Криса Смита Что нужно знать перед обсуждением Типовые системы.

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

  • 0
    Спасибо за указатель. Прочитав - и частично поняв - статью, я могу сказать, что в моем примере языка Lingo нет средства проверки типов. Если действительно убедитесь, что вы не пытаетесь использовать переменную, которая никогда не была назначена, но это все. Тем не менее, я не думаю , что на самом деле ушел понимание того , что динамическая система типа. У меня есть чувство, что это не так, в чем это хорошо, а что нет, но я думаю, что мне нужно что-то менее абстрактное, чтобы действительно обдумать это.
  • 0
    @DanThMan: Я не знаком с Lingo, но я уверен , что у него есть тип системы. Просто звучит, что он очень свободный (то есть он выполняет большое количество неявных преобразований). Система свободных типов часто ассоциируется с «динамическими» языками, но ни в коем случае не является обязательным требованием. Python, например, имеет довольно строгую систему типов, но очень динамически типизирован. На мой взгляд, динамически типизированные языки полезны для многих вещей, но слабо типизированные языки - это просто хороший способ поставить вас в неприятности. YMMV.
0

Я хотел бы показать, что Lingo - динамический язык.

Я сделал LingoF Функциональное программирование для Lingo. Эта структура полностью написана в Lingo, no xtra, не используются компоненты низкого уровня, поэтому было бы невозможно разработать такую ​​структуру, если язык не был динамическим.

Учитывая эту структуру, вот моя оценка для Lingo как динамического языка:

1 - Eval - Lingo имеет ключевые слова do и value. Кроме того, вы можете скомпилировать script во время выполнения. См. LingoF Feature "Lingo Expressions".

2 - Функции более высокого порядка - LingoF показывает, насколько возможно широко использовать функции высшего порядка в Lingo.

3 - Закрытие - снова LingoF показывает, как можно работать с Closures в Lingo.

4 - Продолжение - Помощники синтаксиса LingoF определяются с помощью методов продолжения. В функции Continuation Passing Style можно писать функции. Проверьте это (взято из модуля LingoF):

on public_factorialCPS_2
on fac me, n,k
  x = LingoF().var()
  if ( n = 0 ) then return k [1] 
  else return me.factorialCPS[$(#-,n,1) ] [ LingoF().fun(x) [ k [ $(#*,n,x) ]  ] ]
end

5 - Отражение - уже ответил да, и я согласен. Например, менеджер модуля LingoF реализован с использованием функций Lingo Reflection, упомянутых DanM.

6 - Макросы - мне придется делать больше исследований в этой области. Поскольку Director поддерживает Linked Scripts (скрипты, хранящиеся во внешних текстовых файлах), можно реализовать некоторые макросы. Может быть, менеджер макросов может перехватить некоторые события типа startMovie (для их расширения) и stopMovie (чтобы сжать их снова). Другая возможность - использовать поля в качестве скриптов и расширять их в script членах, я уверен, что он будет работать нормально.

Итак, мой результат от 5 до 6 из 6 по динамическим функциям.

Сообщество Overcoder
Наверх
Меню