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

Question

Я пытаюсь лучше понять, что на самом деле означает «динамический» язык. У меня довольно большой опыт работы с 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]]. Разве это не будет похоже на tuple?

Достаточно ли этих функций для получения статуса "динамический язык"?

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

EDIT

Что касается ответа Марка Рушакова, ниже приведена попытка проанализировать, можно ли считать Линго «динамическим», используя эту статью в Википедии :

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

2. Функции высшего порядка - Если я правильно понимаю, это в основном то, что я бы назвал «делегатом» в C #. Насколько я знаю, Lingo не поддерживает это напрямую, хотя вы можете создать тип (называемый «родительский скрипт»), который имеет функцию и передает экземпляр типа.

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

4. Продолжение - Насколько я знаю, это не поддерживается.

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

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

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

Answer 1

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

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

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

Answer 2

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

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

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

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

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

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

String s = "hello"

когда это очевидно только с

s = "hello"

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

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

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

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

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

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

Answer 3

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

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

Answer 4

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

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

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

1 - Eval - в Lingo есть ключевые слова do и value. Плюс вы можете скомпилировать скрипт во время исполнения. См. Функцию LingoF "Выражения Lingo".

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

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

4 - Продолжение - помощники синтаксиса LingoF определяются с помощью методов продолжения. Можно писать функции в стиле продолжения продолжения. Проверьте это (взято из модуля 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, упомянутых DanM.

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

Таким образом, по динамическим характеристикам у меня 5-6 баллов.