Стандартный ML

Стандартный ML
Парадигма	Мультипарадигмальность : функциональная , императивная , модульная.
Семья	МЛ
Впервые появился	1983 год ; 41 год назад
Стабильная версия	Стандартный ML '97 / 1997 ; 27 лет назад
Дисциплина набора текста	Предполагаемый , статичный , сильный
Расширения имен файлов	.sml
Веб-сайт	смлсемья .github .что
Основные реализации
	СМЛ/Нью-Джерси , MLton , Поли/ML
Диалекты
	Алиса , Параллельное ML , Зависимое ML
Под влиянием
	МЛ , Хоуп , Паскаль
Под влиянием
	Elm , F# , F* , Haskell , OCaml , Python , Ржавчина , Скала

Standard ML ( SML ) — это назначения высокого уровня с модульный функциональный общего язык программирования во время компиляции проверкой типов и выводом типов . Он популярен при написании компиляторов , при исследовании языков программирования и при разработке средств доказательства теорем .

Стандартный ML — это современный диалект ML , языка, используемого в Логика для вычислимых функций» проекте доказательства теорем « (LCF). Среди широко используемых языков он отличается тем, что имеет формальную спецификацию , представленную в виде правил типизации и операционной семантики в «Определении стандартного машинного обучения» . ^[5]

Язык [ править ]

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

Функции [ править ]

Как и во всех функциональных языках, ключевой особенностью Standard ML является функция , которая используется для абстракции. Факториал можно выразить следующим образом:

весело   факториал   n   =  
     если   n   =   0   , то   1   иначе   n   *   факториал   (  n   -   1  )

Вывод типа [ править ]

Компилятор SML должен определить статический тип. val factorial : int -> intбез предоставленных пользователем аннотаций типов. Это должно сделать вывод n используется только с целочисленными выражениями и, следовательно, само должно быть целым числом, а все терминальные выражения являются целочисленными выражениями.

определения Декларативные

Та же самая функция может быть выражена с помощью определений клаузальных функций , где условие if - then - else заменяется шаблонами факториальной функции, вычисляемой для определенных значений:

забавный   факториал   0   =   1 
   |    факториал   n   =   n   *   факториал   (  n   -   1  )

Определения императива [ править ]

или итеративно:

fun   факториал   n   =   let   val   i   =   ref   n   и   acc   =   ref   1   in 
     while   !i   >   0   do   (  acc   :=   !acc   *   !i  ;   i   :=   !i   -   1  );    !акк 
 конец

Лямбда-функции [ править ]

или как лямбда-функция:

val   Rec   Factorial   =   fn   0   =>   1   |    n   =>   n   *   факториал   (  n   -   1  )

Здесь ключевое слово val вводит привязку идентификатора к значению, fn вводит анонимную функцию и rec позволяет определению быть самореферентным.

Местные определения [ править ]

Инкапсуляция сохраняющего инвариант жесткого цикла хвостовой рекурсии с одним или несколькими параметрами аккумулятора внутри безинвариантной внешней функции, как показано здесь, является распространенной идиомой в стандартном машинном обучении.

Используя локальную функцию, ее можно переписать в более эффективном стиле хвостовой рекурсии:

локальный 
     веселья   цикл   (  0  ,   акк  )   =   акк 
       |    цикл   (  m  ,   Acc  )   =   цикл   (  m   -   1  ,   m   *   Acc  ) 
 в 
     веселья   факториале   n   =   цикл   (  n  ,   1  ) 
 конец

Введите синонимы [ править ]

Синоним типа определяется ключевым словом type. Вот синоним типа для точек на плоскости и функции, вычисляющие расстояния между двумя точками и площадь треугольника с заданными углами по формуле Герона . (Эти определения будут использоваться в последующих примерах).

type   loc   =   Real   *   Real 

 fun   Square   (  x   :   Real  )   =   x   *   x 

 fun   dist   (  x  ,   y  )   (  x'  ,   y'  )   = 
     Math  .   sqrt   (  квадрат   (  x'   -   x  )   +   квадрат   (  y'   -   y  )) 

 fun   цапля   (  a  ,   b  ,   c  )   =   let 
     val   x   =   dist   a   b 
     val   y   =   dist   b   c 
     val   z   =   dist   a   c 
     val   s   =   (  x   +   y   +   z  )   /   2.0 
     по 
         математике  .   sqrt   (  s   *   (  s   -   x  )   *   (  s   -   y  )   *   (  s   -   z  )) 
     конец

Алгебраические типы данных [ править ]

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

В объектно-ориентированных языках программирования несвязное объединение может быть выражено в виде классов иерархии . Однако, в отличие от иерархий классов , ADT закрыты . Таким образом, расширяемость АТД ортогональна расширяемости иерархий классов. Иерархии классов могут быть расширены новыми подклассами, реализующими тот же интерфейс, а функции АТД могут быть расширены для фиксированного набора конструкторов. См. проблему с выражением .

Тип данных определяется ключевым словом datatype, как в:

тип данных   shape 
     =   Круг     loc   *   real   (        * центр и радиус *) 
     |    Квадрат     loc   real   *   )        (* верхний левый угол и длина стороны; выровнено по оси * 
     |    Треугольник   loc   loc   *   loc   *   (* углы   *)

Обратите внимание, что синоним типа не может быть рекурсивным; типы данных необходимы для определения рекурсивных конструкторов. (В данном примере это не обсуждается.)

Сопоставление с образцом [ править ]

Шаблоны сопоставляются в том порядке, в котором они определены. на C Программисты могут использовать тегированные объединения , диспетчеризируя значения тегов, чтобы делать то, что ML делает с типами данных и сопоставлением с образцом. Тем не менее, хотя программа C, оснащенная соответствующими проверками, в некотором смысле будет такой же надежной, как и соответствующая программа ML, эти проверки обязательно будут динамическими; ML Статические проверки обеспечивают надежную гарантию корректности программы во время компиляции.

Аргументы функции можно определить как шаблоны следующим образом:

 развлечений  зона   (  Круг   (_,   r  ))   =   Math  .   пи   *   квадрат   r 
   |    площадь   (  Квадрат   (_,   с  ))   =   квадрат   с 
   |    площадь   (  Треугольник   p  )   =   цапли   p   (*см. выше *)

Так называемая «клаузальная форма» определения функции, в которой аргументы определяются как шаблоны, является просто синтаксическим сахаром для регистрового выражения:

 забавной   области  Форма   =   корпуса   форма   Circle 
     (   _,   r  )   =>   Math  .   пи   *   квадрат   r 
   |    Квадрат   (_,   s  )   =>   квадрат   s 
   |    Треугольник   p   =>   цапля   p

Проверка полноты [ править ]

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

Следующий шаблон не является исчерпывающим:

 развлечений  центр   (  Круг   (  c  ,   _))   =   c 
   |    центр   (  Квадрат   ((  x  ,   y  ),   s  ))   =   (  x   +   s   /   2,0  ,   y   +   s   /   2,0  )

Не существует шаблона для Triangle дело в centerфункция. Компилятор выдаст предупреждение о том, что выражение case не является исчерпывающим, и если Triangle передается этой функции во время выполнения, exception Match будет повышен.

Проверка избыточности [ править ]

Шаблон во втором предложении следующей (бессмысленной) функции является избыточным:

весело   ж   (  Круг   ((  Икс  ,   y  ),   р  ))   знак равно   Икс   +   y 
   |    ж   (  Круг   _)   =   1,0 
   |    ж   _   =   0,0

Любое значение, соответствующее шаблону во втором предложении, будет также соответствовать шаблону в первом предложении, поэтому второе предложение недостижимо. Таким образом, это определение в целом демонстрирует избыточность и вызывает предупреждение во время компиляции.

Следующее определение функции является исчерпывающим и не является избыточным:

val   hasCorners   =   fn   (  Circle   _)   =>   false   |    _   =>   правда

Если управление проходит первый шаблон ( Circle), мы знаем, что форма должна быть либо Square или Triangle. В любом из этих случаев мы знаем, что у фигуры есть углы, поэтому мы можем вернуться true не различая фактической формы.

Функции высшего порядка [ править ]

Функции могут использовать функции в качестве аргументов:

забавная   карта   ж   (  Икс  ,   y  )   знак равно   (  ж   Икс  ,   ж   y  )

Функции могут создавать функции как возвращаемые значения:

 веселья  константа   k   =   (  fn   _   =>   k  )

Функции также могут как потреблять, так и производить функции:

весело   сочинять   (  ж  ,   г  )   =   (  fn   x   =>   ж   (  г   Икс  ))

Функция List.map из базовой библиотеки — одна из наиболее часто используемых функций высшего порядка в Standard ML:

забавная   карта   _   []   =   [] 
   |    карта   f   (  x   ::   xs  )   =   f   x   ::   карта   f   xs

Более эффективная реализация с хвостовой рекурсией List.foldl:

забавная   карта   f   =   Список  .   ред.   о   Список  .   foldl   (  fn   (  x  ,   акк  )   =>   ж   x   ::   акк  )   []

Исключения [ править ]

Исключения возникают с помощью ключевого слова raise и обрабатывается с помощью сопоставления с образцом handleпостроить. Система исключений может реализовать нелокальный выход ; этот метод оптимизации подходит для таких функций, как следующие.

локальное 
     исключение   Zero  ; 
      val   p   =   fn   (  0  ,   _)   =>   поднять   ноль   |    (  a  ,   b  )   =>   a   *   b 
 в 
     fun   prod   xs   =   List  .   foldl   p   1   xs   дескриптор   Ноль   =>   0 
 конец

Когда exception Zero поднимается, управление выходит из функции List.foldlвообще. Рассмотрим альтернативу: будет возвращено значение 0, оно будет умножено на следующее целое число в списке, будет возвращено полученное значение (неизбежно 0) и так далее. Вызов исключения позволяет элементу управления пропустить всю цепочку кадров и избежать связанных с ней вычислений. Обратите внимание на использование подчеркивания ( _) как шаблон подстановочного знака.

Ту же самую оптимизацию можно получить с помощью хвостового вызова .

локальное 
     развлечение   p   a   (  0   ::   _)   =   0 
       |    п   а   (  Икс   ::   xs  )   знак равно   п   (  a   *   x  )   xs 
       |    p   a   []   =   a 
 in 
     val   prod   =   p   1 
 end

Система модулей [ править ]

Расширенная система модулей Standard ML позволяет разлагать программы на иерархически организованные структуры логически связанных типов и определений значений. Модули обеспечивают не только управление пространством имен , но и абстракцию в том смысле, что они позволяют определять абстрактные типы данных . Систему модулей составляют три основные синтаксические конструкции: сигнатуры, структуры и функторы.

Подписи [ править ]

Сигнатура , который — это интерфейс обычно рассматривается как тип структуры; он определяет имена всех сущностей, предоставляемых структурой, арность каждого компонента типа, тип каждого компонента значения и сигнатуру каждой подструктуры. Определения компонентов типа не являются обязательными; Компоненты типа, определения которых скрыты, являются абстрактными типами .

Например, подпись для очереди может быть следующей:

подпись   QUEUE   =   подписи 
     тип   '   очереди 
     исключение   QueueError  ; 
      val   пустой       :   '   очередь 
     val   isEmpty     :   '   очередь   ->   bool 
     val   Singleton   :   'a   ->   '   очередь 
     val   fromList    :   'a   list   ->   '   очередь 
     val   вставка      :   'a   *   '   очередь   ->   '   очередь 
     val   peek        :   'a   Queue   ->   'a 
     val   Remove      :   'a   Queue   ->   'a   *   '   очереди 
 Конец

Эта сигнатура описывает модуль, предоставляющий полиморфный тип. 'a queue, exception QueueErrorи значения, определяющие основные операции с очередями.

Структуры [ править ]

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

Структуру очереди можно реализовать следующим образом:

структура   TwoListQueue   :>   QUEUE   =   struct 
     type   'a   Queue   =   'a   list   *   '   списка 

     исключение   QueueError  ; 

      val   пустой   =   ([],   []) 

     fun   isEmpty   ([],   [])   =   true 
       |    isEmpty   _   =   false 

     fun   синглтон   a   =   ([],   [  a  ]) 

     fun   fromList   a   =   ([],   a  ) 

     fun   Insert   (  a  ,   ([],   []))   =   синглтон   a 
       |    вставить   (  a  ,   (  ins  ,   outs  ))   =   (  a   ::   ins  ,   outs  ) 

     fun   peek   (_,   [])   =   поднять   QueueError 
       |    peek   (  входы  ,   выходы  )   =   Список  .   hd   outs 

     fun   удалить   (_,   [])   =   поднять   QueueError 
       |    удалить   (  ins  ,   [  a  ])   =   (  a  ,   ([],   List  .  rev   ins  )) 
       |    удалить   (  входы  ,   а   ::   выходы  )   =   (  а  ,   (  входы  ,   выходы  )) 
 конец

Это определение заявляет, что structure TwoListQueue реализует signature QUEUE. Кроме того, непрозрачное приписывание, обозначаемое :> утверждает, что любые типы, которые не определены в сигнатуре (т.е. type 'a queue) должен быть абстрактным, то есть определение очереди как пары списков не видно за пределами модуля. Структура реализует все определения в сигнатуре.

Доступ к типам и значениям в структуре можно получить с помощью «точечной записи»:

val   q   :   строка   TwoListQueue  .   очередь   =   TwoListQueue  .   пустой 
 val   q'   =   TwoListQueue  .   вставить   (  Real  .  toString   Math  .  pi  ,   q  )

Функторы [ править ]

Функтор — это функция от структуры к структуре; то есть функтор принимает один или несколько аргументов, которые обычно являются структурами заданной сигнатуры, и в качестве результата создает структуру. Функторы используются для реализации общих структур данных и алгоритмов.

Один популярный алгоритм ^[6]для поиска деревьев в ширину используются очереди. Вот версия этого алгоритма, параметризованная в абстрактной структуре очереди:

(* по Окасаки, ICFP, 2000 *) 
 функтор   BFS   (  Q  :   QUEUE  )   =   struct 
   datatype   'a   Tree   =   E   |    T   of   'a   *   '   дерево   *   '   дерево 

   локальной 
     забавы   bfsQ   q   =   if   Q  .   isEmpty   q   then   []   else   поиск   (  Q  .  удалить   q  ) 
     и   поиск   (  E  ,   q  )   =   bfsQ   q 
       |    найдите   (  T   (  x  ,   l  ,   r  ),   q  )   =   x   ::   bfsQ   (  вставьте   (  вставьте   q   l  )   r  ) 
     и   вставьте   q   a   =   Q  .   вставить   (  a  ,   q  ) 
   в 
     fun   bfs   t   =   bfsQ   (  Q  .  singleton   t  ) 
   конец 
 

 структура   QueueBFS   =   BFS   (  TwoListQueue  )

В пределах functor BFS, представление очереди не видно. Более конкретно, невозможно выбрать первый список в очереди из двух списков, если это действительно используемое представление. Этот механизм абстракции данных делает поиск в ширину действительно независимым от реализации очереди. В целом это желательно; в этом случае структура очереди может безопасно поддерживать любые логические инварианты, от которых зависит ее корректность, за пуленепробиваемой стеной абстракции.

Примеры кода [ править ]

Фрагменты кода SML легче всего изучать, вводя их в интерактивный файл .

Привет, мир! [ редактировать ]

Далее следует «Привет, мир!» программа :

привет.sml
print "Привет, мир! \n " ;
бить
$ млтон hello.sml $ ./привет Привет, мир!

Алгоритмы [ править ]

Сортировка вставками [ править ]

Сортировка вставкой для int list (по возрастанию) можно кратко выразить следующим образом:

забавная   вставка   (  x  ,   [])   =   [  x  ]   |    вставить   (  x  ,   h   ::   t  )   =   sort   x   (  h  ,   t  ) 
 и   sort   x   (  h  ,   t  )   =   if   x   <   h   then   [  x  ,   h  ]   @   t   else   h   ::   Insert   (  x  ,   t  ) 
 val   Insertionsort   =   Список  .   сложить   вставку   []

Сортировка слиянием [ править ]

Здесь классический алгоритм сортировки слиянием реализован в трех функциях: разделение, слияние и сортировка слиянием. Также обратите внимание на отсутствие типов, за исключением синтаксиса op :: и []которые обозначают списки. Этот код будет сортировать списки любого типа при условии, что функция упорядочивания будет последовательной. cmpопределено. Используя вывод типа Хиндли-Милнера , можно вывести типы всех переменных, даже таких сложных типов, как тип функции. cmp.

Расколоть

fun split реализуется с замыканием с отслеживанием состояния , которое чередуется между true и false, игнорируя ввод:

fun   alternator   {}   =   let   val   state   =   ref   true 
     in   fn   a   =>   !state   before   state   :=   not   (  !state  )   end 

 (* Разделить список на почти половинки, которые либо будут одинаковой длины, 
 * либо первая будет иметь на один элемент больше, чем другой. 
 * Выполняется за время O(n), где n = |xs| 
 *) 
 fun   Split   xs   =   List  .   раздел   (  генератор   {})   xs

Объединить

Для повышения эффективности слияние использует локальный функциональный цикл. Внутренний loop определяется в терминах случаев: когда оба списка непусты ( x :: xs) и когда один список пуст ( []).

Эта функция объединяет два отсортированных списка в один. Обратите внимание, как аккумулятор accстроится задом наперед, а затем переворачивается перед возвратом. Это распространенный метод, поскольку 'a listпредставляется в виде связанного списка ; этот метод требует больше тактового времени, но асимптотика не хуже.

(* Объединить два упорядоченных списка, используя порядок cmp. 
 * Предварительно: каждый список уже должен быть упорядочен для каждого cmp. 
 * Выполняется за время O(n), где n = |xs| + |ys|. 
 *) 
 fun   merge   cmp   (  xs  ,   [])   =   хз 
   |    объединить   cmp   (  xs  ,   y   ::   ys  )   =   let 
     fun   Loop   (  a  ,   acc  )   (  xs  ,   [])   =   List  .   revAppend   (  a   ::   acc  ,   xs  ) 
       |    цикл   (  a  ,   acc  )   (  xs  ,   y   ::   ys  )   = 
         if   cmp   (  a  ,   y  ) 
         then   цикл   (  y  ,   a   ::   acc  )   (  ys  ,   xs  ) 
         else   цикл   (  a  ,   y   ::   acc  )   (  xs  ,   ys  ) 
     в 
         цикле   (  y  ,   [])   (  ys  ,   xs  ) 
     конец

Сортировка слиянием

Основная функция:

fun   ap   f   (  x  ,   y  )   =   (  f   x  ,   f   y  ) 

 (* Сортировка списка в соответствии с заданной операцией упорядочивания cmp. 
 * Выполняется за время O(n log n), где n = |xs|. 
 *) 
 весело   слиянием   cmp   []   =   [] 
   |    сортировка слиянием   cmp   [  x  ]   =   [  x  ] 
   |    mergesort   cmp   xs   =   (  merge   cmp   o   ap   (  mergesort   cmp  )   o   Split  )   xs

Быстрая сортировка [ править ]

Быструю сортировку можно выразить следующим образом. fun part это замыкание , которое использует оператор заказа op <<.

infix   << 

 fun   fastsort   (  op   <<  )   =   let 
     fun   part   p   =   List  .   раздел   (  fn   x   =>   x   <<   p  ) 
     fun   sort   []   =   [] 
       |    sort   (  p   ::   xs  )   =   join   p   (  часть   p   xs  ) 
     и   join   p   (  l  ,   r  )   =   sort   l   @   p   ::   sort   r 
     в 
         сортировки 
     конце

Интерпретатор выражений [ править ]

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

исключение   TyErr  ; 

  тип данных   ty   =   IntTy   |    BoolTy 

 fun   unify   (  IntTy  ,   IntTy  )   =   IntTy 
   |    унифицировать   (  BoolTy  ,   BoolTy  )   =   BoolTy 
   |    унифицировать   (_,   _)   =   повысить   TyErr 

 тип данных   exp 
     =   True 
     |    Ложь 
     |    Int   из   int 
     |    Не   опыта   
     |    Добавление   опыта     *   exp 
     |    Если    exp   exp   *   ,   *   exp 

 fun   выводится   True   =   BoolTy 
   |    сделать вывод   Ложь   =   BoolTy 
   |    вывести   (  Int   _)   =   IntTy 
   |    вывести   (  Не   е  )   =   (  утверждать   е   BoolTy  ;   BoolTy  ) 
   |    вывести   (  Add   (  a  ,   b  ))   =   (  утвердить   a   IntTy  ;   утвердить   b   IntTy  ;   IntTy  ) 
   |    вывести   (  If   (  e  ,   t  ,   f  ))   =   (  утвердить   e   BoolTy  ;   объединить   (  вывести   t  ,   вывести   f  )) 
 и   утвердить   e   t   =   унифицировать   (  вывести   e  ,   t  ) 

 fun   eval   True   =   True 
   |    оценка   Ложь   =   Ложь 
   |    оценка   (  Int   n  )   =   Int   n 
   |    eval   (  Not   e  )   =   если   eval   e   =   True   , то   False   , иначе   True 
   |    eval   (  Add   (  a  ,   b  ))   =   (  случай   (  eval   a  ,   eval   b  )   of   (  Int   x  ,   Int   y  )   =>   Int   (  x   +   y  )) 
   |    eval   (  If   (  e  ,   t  ,   f  ))   =   eval   (  если   eval   e   =   True   , то   t   else   f  ) 

 fun   run   e   =   (  infer   e  ;   SOME   (  eval   e  ))   handle   TyErr   =>   NONE

Пример использования правильно типизированных и неправильно типизированных выражений:

val   SOME   (  Int   3  )   =   run   (  Add   (  Int   1  ,   Int   2  ))   (* правильно типизированный *) 
 val   NONE   =   run   (  If   (  Not   (  Int   1  ),   True  ,   False  ))   (* неправильно типизированный *)

Целые числа произвольной точности [ править ]

The IntInfМодуль обеспечивает целочисленную арифметику произвольной точности. Более того, целочисленные литералы могут использоваться как целые числа произвольной точности без необходимости каких-либо действий программиста.

Следующая программа реализует функцию факториала произвольной точности:

факт.sml

интересный   факт   :     IntInf  .   int   =   если   n   =   0,   то   1   иначе   n   *   факт   (  n   -   1  ); 

  весело   printLine   str   =   TextIO  .   вывод   (  TextIO  .  stdOut  ,   str   ^   "  \n  "  ); 

  val   )   =   printLine   (  IntInf.toString  120  факт   (  )   (  );

бить

$  млтон   факт.sml 
  $  ./факт 
  6689502913449127057588118054090372586752746333138029810295671352301 
 633557244962989366874165271984981308157637893214090552 
 5344085894081 21859898481114389650005964960521256960000000000000000000000000000

Частичное применение [ править ]

Каррированные функции имеют множество применений, например, для устранения избыточного кода. Например, модулю могут потребоваться функции типа a -> b, но удобнее писать функции типа a * c -> b где существует фиксированная связь между объектами типа a и c. Функция типа c -> (a * c -> b) -> a -> bможно исключить эту общность. Это пример шаблона адаптера . ^{[ нужна цитата ]}

В этом примере fun d вычисляет числовую производную заданной функции f в точку x:

-   fun   d   delta   f   x   =   (  f   (  x   +   delta  )   -   f   (  x   -   delta  ))   /   (  2,0   *   delta  ) 
 val   d   =   fn   :   реальный   ->   (  реальный   ->   реальный  )   ->   реальный   ->   реальный

Тип fun d указывает, что он отображает «плавающее число» на функцию типа (real -> real) -> real -> real. Это позволяет нам частично применять аргументы, известные как каррирование . В этом случае функция d можно специализировать, частично применив его с аргументом delta. Хороший выбор для delta при использовании этого алгоритма это кубический корень из машинного эпсилона . ^{[ нужна цитата ]}

-   val   d'   =   d   1E~8  ; 
  val   d'   =   fn   :   (  реальный   ->   реальный  )   ->   реальный   ->   реальный

Выведенный тип указывает на то, что d' ожидает функцию типа real -> realв качестве первого аргумента. Мы можем вычислить приближение к производной $f(x)=x^{3}-x-1$ в $x=3$ . Правильный ответ $f'(3)=27-1=26$ .

-   d'   (  fn   x   =>   x   *   x   *   x   -   x   -   1,0  )   3,0  ; 
  val   it   =   25,9999996644   :   реальный

Библиотеки [ править ]

Стандартный [ править ]

Базовая библиотека ^[7]был стандартизирован и поставляется с большинством реализаций. Он предоставляет модули для деревьев, массивов и других структур данных, а также интерфейсы ввода/вывода и системные интерфейсы.

Третья сторона [ править ]

Для числовых вычислений существует модуль Matrix (но в настоящее время он не работает) https://www.cs.cmu.edu/afs/cs/project/pscico/pscico/src/matrix/README.html .

Что касается графики, cairo-sml — это интерфейс с открытым исходным кодом для графической библиотеки Cairo . Для машинного обучения существует библиотека графических моделей.

Реализации [ править ]

Реализации Standard ML включают следующее:

Стандартный

HaMLet : стандартный интерпретатор машинного обучения, призванный стать точной и доступной эталонной реализацией стандарта.
MLton ( mlton.org ): компилятор , оптимизирующий всю программу , который строго соответствует определению и создает очень быстрый код по сравнению с другими реализациями ML, включая серверные части для LLVM и C.
Московское машинное обучение : облегченная реализация, основанная на движке среды выполнения Caml Light, который реализует полный стандартный язык машинного обучения, включая модули и большую часть базовой библиотеки.
Poly/ML : полная реализация Standard ML, которая создает быстрый код и поддерживает многоядерное оборудование (через потоки интерфейса переносимой операционной системы ( POSIX ); его система времени выполнения выполняет параллельную сборку мусора и совместное использование неизменяемых подструктур в режиме онлайн.
Standard ML of New Jersey ( smlnj.org ): полный компилятор со связанными библиотеками, инструментами, интерактивной оболочкой и документацией с поддержкой Concurrent ML.
SML.NET : стандартный компилятор ML для среды CLR с расширениями для связывания с другим .NET. кодом платформы
Комплект ML . Архивировано 7 января 2016 г. на Wayback Machine : реализация, очень близко основанная на определении, интегрирующая сборщик мусора (который можно отключить) и управление памятью на основе регионов с автоматическим выводом регионов с целью поддержки режима реального времени. Приложения

Производная

Алиса : интерпретатор Standard ML от Саарского университета с поддержкой параллельного программирования с использованием фьючерсов , ленивых вычислений , распределенных вычислений посредством удаленных вызовов процедур и программирования с ограничениями.
SML# : расширение SML, обеспечивающее полиморфизм записей и совместимость с языком C. Это обычный собственный компилятор, и его название не является намеком на работу на платформе .NET.
SOSML : реализация, написанная на TypeScript , поддерживающая большую часть языка SML и избранные части базовой библиотеки.

Исследовать

CakeML — это REPL-версия ML с формально проверенной средой выполнения и переводом на ассемблер.
Isabelle ( Isabelle/ML. Архивировано 30 августа 2020 г. на Wayback Machine ) интегрирует параллельный Poly/ML в интерактивное средство доказательства теорем со сложной интегрированной средой разработки (на основе jEdit ) для официального стандарта ML (SML'97), Isabelle/ML. диалект и язык доказательства. Начиная с Isabelle2016, для ML также доступен отладчик уровня исходного кода.
Poplog реализует версию Standard ML вместе с Common Lisp и Prolog , что позволяет программировать на смешанных языках; все они реализованы в POP-11 , который компилируется постепенно .
TILT — это полностью сертифицированный компилятор для Standard ML, который использует типизированные промежуточные языки для оптимизации кода и обеспечения корректности и может компилироваться в типизированный ассемблер .

Все эти реализации имеют открытый исходный код и доступны бесплатно. Большинство из них реализованы в Standard ML. Коммерческих реализаций больше нет; Harlequin , ныне несуществующая, когда-то выпустила коммерческую IDE и компилятор под названием MLWorks, которые перешли к Xanalys и позже были открыты с открытым исходным кодом после того, как 26 апреля 2013 года они были приобретены Ravenbrook Limited.

Крупные проекты с использованием SML [ править ]

ИТ -университета Копенгагена Вся корпоративная архитектура реализована примерно в 100 000 строк SML, включая учет персонала, расчет заработной платы, администрирование курсов и обратную связь, управление студенческими проектами и веб-интерфейсы самообслуживания. ^[8]

Помощники доказательства HOL4 , Isabelle , LEGO и Twelf написаны на стандартном ML. Он также используется авторами компиляторов и разработчиками интегральных схем, такими как ARM . ^[9]

См. также [ править ]

Декларативное программирование

Ссылки [ править ]

^ Перейти обратно: ^а ^б «Программирование в стандартном машинном обучении: иерархии и параметризация» . Проверено 22 февраля 2020 г.
^ Перейти обратно: ^а ^б ^с «СМЛ '97» . www.smlnj.org .
^ Перейти обратно: ^а ^б «itertools — Функции, создающие итераторы для эффективного циклирования — документация Python 3.7.1rc1» . docs.python.org .
^ «Влияния — Справочник по ржавчине» . Справочник по ржавчине . Проверено 31 декабря 2023 г.
^ Перейти обратно: ^а ^б Милнер, Робин ; Тофте, Мэдс; Харпер, Роберт; МакКуин, Дэвид (1997). Определение стандарта ОД (пересмотренного) . МТИ Пресс. ISBN 0-262-63181-4 .
^ Перейти обратно: ^а ^б Окасаки, Крис (2000). «Нумерация в ширину: уроки небольшого упражнения по разработке алгоритмов». Международная конференция по функциональному программированию 2000 г. АКМ.
^ «Стандартная базовая библиотека машинного обучения» . smlfamily.github.io . Проверено 10 января 2022 г.
^ Перейти обратно: ^а ^б Тофте, Мэдс (2009). «Стандартный язык ML» . Схоларпедия . 4 (2): 7515. Бибкод : 2009SchpJ...4.7515T . doi : 10.4249/scholarpedia.7515 .
^ Перейти обратно: ^а ^б Алглав, Джейд ; Фокс, Энтони Си Джей; Иштиак, Самин; Мирин, Магнус О.; Саркар, Сусмит; Сьюэлл, Питер; Нарделли, Франческо Заппа (2009). Семантика Power и многопроцессорного машинного кода ARM (PDF) . DAMP 2009. стр. 13–24. Архивировано (PDF) из оригинала 14 августа 2017 г.

Внешние ссылки [ править ]

О стандартном машинном обучении

Пересмотренное определение
Проект GitHub семейства Standard ML, заархивированный 20 февраля 2020 г. на Wayback Machine.
Что такое СМЛ?
Что такое SML '97?

О преемнике МЛ

преемник ML (sML) : эволюция ML с использованием стандартного ML в качестве отправной точки.
HaMLet на GitHub : эталонная реализация для преемника ML

Практичный

Академический

[intro-1] Перейти обратно: ^а ^б «Программирование в стандартном машинном обучении: иерархии и параметризация» . Проверено 22 февраля 2020 г.

[smlnj-2] Перейти обратно: ^а ^б ^с «СМЛ '97» . www.smlnj.org .

[itertools-3] Перейти обратно: ^а ^б «itertools — Функции, создающие итераторы для эффективного циклирования — документация Python 3.7.1rc1» . docs.python.org .

[4] «Влияния — Справочник по ржавчине» . Справочник по ржавчине . Проверено 31 декабря 2023 г.

[revision-5] Перейти обратно: ^а ^б Милнер, Робин ; Тофте, Мэдс; Харпер, Роберт; МакКуин, Дэвид (1997). Определение стандарта ОД (пересмотренного) . МТИ Пресс. ISBN 0-262-63181-4 .

[bfs-6] Перейти обратно: ^а ^б Окасаки, Крис (2000). «Нумерация в ширину: уроки небольшого упражнения по разработке алгоритмов». Международная конференция по функциональному программированию 2000 г. АКМ.

[7] «Стандартная базовая библиотека машинного обучения» . smlfamily.github.io . Проверено 10 января 2022 г.

[sml-8] Перейти обратно: ^а ^б Тофте, Мэдс (2009). «Стандартный язык ML» . Схоларпедия . 4 (2): 7515. Бибкод : 2009SchpJ...4.7515T . doi : 10.4249/scholarpedia.7515 .

[machine_code_verification-9] Перейти обратно: ^а ^б Алглав, Джейд ; Фокс, Энтони Си Джей; Иштиак, Самин; Мирин, Магнус О.; Саркар, Сусмит; Сьюэлл, Питер; Нарделли, Франческо Заппа (2009). Семантика Power и многопроцессорного машинного кода ARM (PDF) . DAMP 2009. стр. 13–24. Архивировано (PDF) из оригинала 14 августа 2017 г.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

v т Это Языки программирования
Сравнение График История
Есть АЛГОЛ АПЛ АркТС Сборка БАЗОВЫЙ С С++ С# Классический Visual Basic КОБОЛ Эрланг Форт Фортран Идти Хаскелл Джава JavaScript Юлия Котлин Лисп Два МАТЛАБ МЛ Объектный Паскаль Паскаль Перл PHP Пролог Питон р Рубин Ржавчина SQL Царапать Оболочка начало Болтовня Быстрый Visual Basic более...
Списки: Алфавитные Категорический Поколенческий Не на английском языке Категория