Является ли Mathematica нетипизированным языком? - PullRequest
15 голосов
/ 30 декабря 2010

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

Например, добавление целочисленного выражения 1 к строковому выражению "foo" в Mathematica приводит к (бессмысленному) выражению 1 + "foo", но без ошибки. В других случаях Mathematica предоставляет обратную связь о бессмысленных входных данных, но проверки, которые генерируют эту обратную связь, должны выполняться явно программистом.

Таким образом, справедливо ли описывать Mathematica как нетипизированный язык в отличие от языка со статической или динамической типизацией?

Ответы [ 5 ]

18 голосов
/ 30 декабря 2010

Вместо «type» у Mathematica есть понятие «голова», где любое выражение Mathematica обладает им.Это соответствует их парадигме "все является выражением" .

. Можно взглянуть на структуру выражения Mathematica через функции FullForm[] и Head[].Например, Head[3] возвращает Integer, Head[2/3] возвращает Rational, Head[I] возвращает Complex, Head[.3] возвращает Real, Head[a] возвращает Symbol (при условии, что вы еще не присвоили что-нибудь до a), Head["a"] возвращает String, Head[{2}] возвращает List ... я уверен, что вы уже поняли идею.

Красота этогов том, что можно писать функции так, что они могут принимать аргументы только с определенными заголовками.Например:

f[x_Real] := x^2

f[3]
f[3]

f[3.]
9.

Эта дискуссия о шаблонах должна дать вам идеи о том, как настроить функции так, чтобы они работали только на объектах с определенными головками или наборами головок.

6 голосов
/ 30 декабря 2010

Если мы рассмотрим фразы «статически типизированный» и «динамически типизированный» как жаргон со ссылкой на то, когда язык проверяет достоверность операций с типами, то я думаю, что было бы справедливо охарактеризовать Mathematica, используя жаргон «нетипизированный» - вощущение, что оно «никогда» не проверяет, является ли операция допустимой для типа.

Однако мне нравится использование Велисарием термина «независимость от типа».Я говорю это потому, что хотя почти вся проверка типов в языке идиоматична (т. Е. Реализуется программистом, а не языком), так же как и концепция применения оператора к типизированным операндам!

Считайте «бессмысленным»пример 1 + "foo".Я думаю, что было бы справедливо сказать, что значительная часть (приближающаяся к единству) всех пользователей Mathematica сталкивается с такими случаями, когда они впервые изучают язык.Проблема особенно очевидна, когда кто-то пишет код, скажем, в стиле C. В кругах Mathematica много обсуждается, как справляться с такими ситуациями.

С другой стороны, эта слабостьтакже величайшая сила Mathematica.Mathematica оптимизирована для создания новых обозначений.Многие, многие обозначения имеют понятие +, которое ведет себя очень похоже на сложение в элементарной арифметике.При построении такого обозначения было бы очень неудобно, если бы Mathematica вмешалась и пожаловалась, что операнды на + не являются числами.В таком высокоуровневом приложении Mathematica «бессмысленный» пример не только «чувственный», но и действительно важный.

Итак, с учетом этого вопрос о типе часто спорен.Следовательно, мне нравится Велизарий '"независимая от типа" характеристика.Подпишись на него, я сделал;)

Редактировать

Я попытаюсь уточнить, что я имел в виду, когда различал «нетипизированный» и «независимый от типа».

Читая различные ответы и комментарии, я попытался выяснить, в чем разница между Mathematica и LISP.Последнее обычно рассматривается как пример «динамически типизированного», хотя основной оценщик LISP очень похож на Mathematica, практически не проверяющий тип.Ошибки типов, которые мы видим в программах LISP, в основном вызываются жестко заданными проверками в (обычно встроенных) функциях.+, например, будет принимать только числовые аргументы, даже если самому оценщику не безразлично, так или иначе.Сказав это, «чувство» программирования в LISP сильно отличается от «ощущения» Mathematica (по крайней мере, для меня).Пример 1 + "foo" действительно отражает эту разницу.

Хотя я в целом согласен с «нетипизированным» в качестве характеристики Mathematica, я все же чувствовал, что чего-то не хватает.Мне кажется, что ассемблер нетипизирован, как и ранний FORTRAN и pre-ANSI C. В этих случаях битовая последовательность аргументов имела значение, и программы продолжали бы беспечно, если бы я передал строковый аргумент, где необходимо целое число.Mathematica, безусловно, разделяет это нетипичное поведение.Но есть разница: в ассемблере, FORTRAN и C такое отсутствие проверки типов крайне редко приводит к хорошему результату.Как я уже упоминал выше, в Mathematica можно, а иногда даже часто полагаться на такое поведение.

Введите "независимый от типа".Мне понравилась его бескомпромиссная позиция, звучащая менее радикально, чем «нетипизированная».Я чувствовал, что это отражает по существу нетипизированную природу Mathematica, но оставил некоторое пространство для маневра для тех языковых возможностей, которые легко поддерживают идиоматическую проверку типов в динамическом стиле LISP (то есть идиома «head» и поддерживающая функциональность).* Итак, короче говоря, я чувствую, что Mathematica колеблется между полной нетипизацией и динамической типизацией.«Тип-агностик» уловил это чувство для меня.YMMV:)

Я с готовностью признаю, что никто, вероятно, не восстановит ничего, что я написал в этом ответе, просто из проверки фраз "нетипизированный" и "независимый от типа". Я еще раз подчеркиваю, что я считаю, что «нетипизированный» является хорошей характеристикой Mathematica, но мне также нравится тот факт, что «независимость от типа» напрашивается на многие вопросы, на которые отвечают различные ответы на этот вопрос SO.

5 голосов
/ 30 декабря 2010

Mathematica имеет несколько типов, и это динамично. У вас есть типы String, Integer, Real, Complex, List и Symbol. Вы можете создавать функции, работающие только с одним типом, делая что-то вроде

f[x_Integer]:=x+1

для создания функции, которая работает только с целыми числами.

Mathematica в значительной степени основана на шаблонах и заменах; мне всегда кажется, что типы - это еще один способ помочь вам в разработке шаблонов. В случае 1 + "foo" отсутствует шаблон для вычисления числа, добавляемого в строку, поэтому результатом является просто само выражение. В случае 1 + 2 существует шаблон для добавления чисел, и он оценивается. Шаблоны и правила замещения Mathematica могут быть гораздо более сложными, и лучше всего читать книгу, если вам интересно.

4 голосов
/ 03 января 2011

Краткий ответ: нетипизированный или не типизированный. Так Wolfram Research описывает продукт самостоятельно. Смотри здесь.

Длинный ответ: Джон, я думаю, твой вопрос действительно зависит от того, что ты имеешь в виду под нетипизированным. Чтобы обратиться к определенному ресурсу, который является Википедия"Напротив, нетипизированный язык, такой как большинство языков ассемблера, позволяет выполнять любую операцию над любыми данными, которые обычно считаются последовательностями битов различных длина «.

Читая предыдущие ответы, кажется, что суть дискуссии заключается в том, что должен проверять тип при обнаружении ошибки. Обычный ответ - ОСТАНОВИТЬ оценку и сообщить о какой-то ошибке. Из нескольких предыдущих вопросов (1) и (2) о Stackoverflow мы можем видеть, что не существует изящного способа сделать это встроенным в Mathematica. (Я хотел бы добавить предостережение о том, что с большим упором на компиляцию в C в версии 8 можно писать код с проверкой типов, но я не уверен, следует ли считать это частью основного языка.)

4 голосов
/ 30 декабря 2010

С практической, а не теоретической стороны вещей, я полагаю, вы можете сказать, что Mathematica больше не зависит от типа, чем нетипизирована.

Кроме того, вы можете легко создать типизированный подязык, используя такие вещи, как (очень простой пример следует):

Unprotect[Set]; 

Set[a, x_] := If[Element[x, Integers], x, 0, 0];  

и попробуйте:

a = 1; (*runs ok*) 

и

a = "caca"  (*assigns zero to a*)

Редактировать

Кроме того, вы можете создавать определяемые пользователем типы как именованные шаблоны и использовать их в переопределении Установить выше вместо целых.
Тип композиции должен работать так же.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...