Является ли Mathematica нетипизированным языком?
В отличие от большинства языков программирования, каждое значение в Mathematica является выражением. Применение любой операции к любому выражению всегда приводит к другому выражению. Следовательно, Mathematica эффективно имеет только один тип. Mathematica не выполняет статическую проверку типов и, возможно, даже не проверяет типы динамически (во время выполнения).
Например, добавление целочисленного выражения 1 к строковому выражению "foo" в Mathematica приводит к (бессмысленному) выражению 1 + "foo" но без ошибок. В других случаях Mathematica предоставляет обратную связь о бессмысленном вводе, но проверки, которые генерируют эту обратную связь, должны выполняться явно программистом.
Таким образом, справедливо ли описывать Mathematica как нетипизированный язык в отличие от статически или динамически типизированного языка?
5 ответов
Краткий ответ: нетипизированный или не типизированный. Вот как Wolfram Research описывает продукт самостоятельно. Посмотреть здесь.
Длинный ответ: Джон, я думаю, твой вопрос действительно зависит от того, что ты имеешь в виду под нетипизированным. Чтобы обратиться к определенному ресурсу, который является Википедией, "В отличие от этого, нетипизированный язык, такой как большинство языков ассемблера, позволяет выполнять любую операцию над любыми данными, которые обычно считаются последовательностями битов различной длины".
Читая предыдущие ответы, кажется, что суть дискуссии заключается в том, что должен проверять тип, когда он сталкивается с ошибкой. Обычный ответ - ОСТАНОВИТЬ оценку и сообщить о какой-то ошибке. Из нескольких предыдущих вопросов (1) и (2) о Stackru мы видим, что не существует изящного способа сделать это встроенным в Mathematica. (Я хотел бы добавить предостережение о том, что с большим упором на компиляцию в C в версии 8 можно писать код с проверкой типов, но я не уверен, следует ли считать это частью основного языка.)
Вместо "типа" у 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.
Это обсуждение шаблонов должно дать вам идеи о том, как настроить функции так, чтобы они работали только на объектах с определенными головками или наборами головок.
Если мы рассмотрим фразы "статически типизированный" и "динамически типизированный" как жаргон со ссылкой на то, когда язык проверяет достоверность операций с типами, то я думаю, что было бы справедливо охарактеризовать 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.
Mathematica имеет несколько типов, и она динамична. У вас есть типы String, Integer, Real, Complex, List а также Symbol, Вы можете создавать функции, работающие только с одним типом, делая что-то вроде
f[x_Integer]:=x+1
создать функцию, которая работает только с целыми числами.
Mathematica в значительной степени основана на шаблонах и заменах; мне всегда кажется, что типы - это еще один способ помочь вам в разработке шаблонов. В случае 1 + "foo"нет шаблона для вычисления числа, добавляемого в строку, поэтому результатом является просто само выражение. В случае 1 + 2, есть шаблон для добавления чисел, и он оценивается. Шаблоны и правила замещения Mathematica могут быть намного более сложными, и лучше всего читать книгу, если вам интересно.
Больше из практической, чем теоретической стороны вещей, я полагаю, вы можете сказать, что Mathematica больше зависит от типа, чем от нетипизированного.
Более того, вы можете легко создать типизированный подязык, используя такие вещи, как (очень простой пример следует):
Unprotect[Set];
Set[a, x_] := If[Element[x, Integers], x, 0, 0];
а затем попробуйте:
a = 1; (*runs ok*)
а также
a = "caca" (*assigns zero to a*)
редактировать
Более того, вы можете создавать пользовательские типы как именованные шаблоны и использовать их в переопределении Set выше вместо целых чисел.
Тип композиции должен работать так же.