**Standard ML**-ը (**SML**), ընդհանուր նշանակության, մոդուլյար, ֆունկցիոնալ ծրագրավորման լեզու է՝ կոմպիլյացիայի ժամանակ տիպերի ստուգման և տիպերի ավտոմատ դուրսբերման ներդրված մեխանիզմներով։ Այն առավել հայտնի է կոմպիլյատորների ստեղծման, ծրագրավորման լեզուների հետազոտման, ինչպես նաև թեորեմների ավտոմատ ապացուցման ոլորտներում)
։

SML-ը «Հաշվարկելի ֆունկցիաների տրամաբանություն» թեորեմների ավտոմատ ապացուցման նախագծում օգտագործվող ML ծրագրավորման լեզվի ժամանակակից զարգացումն է։

Լեզվի կառուցվածքը
-----------------

Standard ML-ը ֆունկցիոնալ ծրագրավորման լեզու է՝ որոշ ոչ-ֆուկցիոնալ (իմպերատիվ) տարրերով։ SML լեզվով գրված ծրագրերը բաղկացած են հաշվարկման ենթակա արտահայտություններից, որոնցից որոշները վերադարձնում են հատուկ `unit` տիպի արժեք և հաշվարկվում են միայն կողմնակի էֆեկտներ ստանալու համար։

Ինչպես բոլոր ֆունկցիոնալ ծրագրավորման լեզուներում, SML-ի կարևորագույն բաղադրիչը ֆունկցիան է, որն էլ օգտագործվում է որպես հիմնական աբստրակցիայի մեխանիզմ։ Օրինակ, հայտնի ֆակտորիալ կարելի է արտահայտել հետևյալ կերպ.

```
 fun factorial n = 
  if n = 0 then 1 else n \* factorial (n-1)

```

SML-ի կոմպիլյատորը այս ֆունկցիայի համար ստատիկ եղանակով դուրս է բերում int -> int տիպը։ Այսինքն, այն եզրակացնում է, որ եթե n-ը օգտագործված է միայն ամբողջաթիվ արտահայտության մեջ, ապա ինքն էլ պետք է ամբողջ թիվ լինի, հետևաբար, արժեքը ձևավորող ամբողջ արտահայտության տիպը նույնպես պետք է ամբողջաթիվ լինի։

Նույն ֆունկցիան կարելի է արտահայտել նաև *տարբերակներով ֆունկցիայի սահմանումով*, որտեղ *if*-*then*-*else* պայմանը փոխարինված է ֆակտորիալ ֆունկցիայի առանձին արժեքները հաշվող շաբլոնների հաջորդականությամբ։ `|` նիշով իրարից անջատված այդ շաբլոնները հաջորդաբար դիտարկվում են այնքան ժամանակ, քանի դեռ համապատասխանություն չի հայտնաբերվել.

```
 fun factorial 0 = 1
  | factorial n = n \* factorial (n - 1)

```

Նույնը կարելի է ձևակերպել նաև `case` կառուցվածքի օգտագործմամբ.

```
 val rec factorial =
  fn n => case n of 0 => 1
 | n => n \* factorial (n - 1)

```

Կամ լյամբդա-արտահայտության օգտագործմամբ.

```
 val rec factorial = fn 0 => 1 | n => n \* factorial(n -1)

```

Այստեղ `val` ծառայողական բառը կատարման միջավայր է ներմուծում նոր *անուն*—*արժեք* կապ (binding), իսկ `fn` կառուցվածքը ստեղծում է անանուն ֆունկցիայի նոր սահմանում։

Լոկալ ֆունկցիայի օգտագործմամբ ֆակտորիալը սահմանող ֆունկցիան կարելի է սահմանել ավելի արդյունավետ տարբերակով՝ *վերջին կանչի ռեկուրսիայի* կիրառումով.

```
 fun factorial n = let
 fun lp (0, acc) = acc
  | lp (m, acc) = lp (m-1, m\*acc)
 in
  lp (n, 1)
 end

```

(`let`-արտահայտության արժեքը `in` և `end` բառերի միջև ընկած արտահայտության արժեքն է։) Մեկ կամ ավելի կուտակող (ակումուլյատոր) պարամետրերով վերջին կանչով (tail-call) ռեկուրսիվ ֆունկցիայի պարփակումը ինվարիանտներից ազատ արտաքին ֆունկցիայիում, ինչպես կատարված է այստեղ, Standard ML լեզում ընդունված հնարք է և բավականին հաճախ է հանդիպում SML ծրագրերում։

### Տիպի հոմանիշ

*Տիպի հոմանիշը* սահմմանվում է `type` ծառայողական բառով։ Ստորև հարթության կետի համար սահմանված է տիպի հոմանիշ։ Սահմանված են նաև երկու կետերի հեռավորությունը և գագաթներով տրված եռանկյան մակերեսը Հերոնի բանաձևով հաշվող ֆունկցիաները։

```
 type loc = real \* real

 fun dist ((x0, y0), (x1, y1)) = let
 val dx = x1 - x0
 val dy = y1 - y0
 in
  Math.sqrt (dx \* dx + dy \* dy)
 end

 fun heron (a, b, c) = let
 val ab = dist (a, b)
 val bc = dist (b, c)
 val ac = dist (a, c)
 val perim = ab + bc + ac
 val s = perim / 2.0
 in
  Math.sqrt (s \* (s - ab) \* (s - bc) \* (s - ac))
 end

```

### Բարձր կարգի ֆունկցիաներ

Ֆունկցիաները կարող են արգումենտում ստանալ այլ ֆունկցիաներ.

```
 fun applyToBoth f x y = (f x, f y)

```

ֆունկցիաները որպես արդյունք կարող են վերադարձնել ֆունկցիաներ.

```
 fun constantFn k = let
 fun const anything = k
  in
 const
  end

```

(այլ կերպ)

```
 fun constantFn k = (fn anything => k)

```

Ֆունկցիաները կարող են միաժամանակ ստանալ և վերադարձնել ֆունկցիաներ.

```
 fun compose (f, g) = let
 fun h x = f (g x)
  in
 h
  end

```

(այլ կերպ)

```
 fun compose (f, g) = (fn x => f (g x))

```

Հիմնական գրադարանի `List.map` ֆունկցիան Standard ML լեզվում առավել հաճախ օգտագործվող բարձր կարգի ֆունկցիաներից է

```
 fun map \_ [] = []
  | map f (x::xs) = f x :: map f xs

```

(`map` ֆունկցիայի ավելի արդյունավետ իրականացումը կարող է սահմանվել հետևյալ կերպ.)

```
 fun map f xs = let
 fun m ([], acc) = List.rev acc
 | m (x::xs, acc) = m (xs, f x :: acc)
  in
 m (xs, [])
  end

```

### Բացառություններ

Բացառությունները գործարկվում (ստեղծվում) են `raise` ծառայողական բառով, և մշակվում են շաբլոնների համապատասխանեցման `handle` կառուցվածքով։

```
 exception Undefined
 fun max [x] = x
  | max (x::xs) = let val m = max xs in if x > m then x else m end
  | max [] = raise Undefined
 fun main xs = let
 val msg = (Int.toString (max xs)) handle Undefined => "empty list...there is no max!"
  in
 print (msg ^ "\n")
  end

```

Իրականացումներ
--------------

* **Standard ML of New Jersey** (SML/NJ) — ամբողջական կոմպիլյատոր և ինտերպրետատոր է, գրադարաններ, գործիքներ և փաստաթղթեր։
* **Moscow ML** — Caml լեզվի միջուկի օգտագործմամբ իրականացված կոմպիլյատոր է։ Իրականացված է ամբողջ Standard ML ստանդարտը, մոդուլների համակարգը, Basis գրադարանի մեծ մասը։

Ծանոթագրություններ
------------------

1. ↑
2. ↑  Milner, R.; Tofte M. Harper R. and MacQueen D. (1997). *The Definition of Standard ML (Revised)*. MIT Press. ISBN 0-262-63181-4.

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * դ
* ք
* խ
Հիմնական ծրագրավորման լեզուները (համեմատումը  • IDE  • պատմությունը  • ժամանակագրութունը) |
| --- |
|  |
| Օգտագործվողլեզուները | 
Ada •
APL •
Ասեմբլեր •
ActionScript •
ABAP/4 •
AutoIt •
AWK •
Basic •
C •
Կոբոլ •
C++ •
C# •
Cω •
Clarion •
Clojure •
ColdFusion •
Common Lisp •
D •
dBase •
Delphi •
Eiffel •
Erlang •
Euphoria •
F# •
Fort •
Fortran •
Gambas •
Go •
Groovy •
HAL/S •
Haskell •
Icon •
Ջավա •
ՋավաՍկրիպտ •
Limbo •
Lua •
Mudula-3 •
Object Pascal •
Objective-C •
OCaml •
Oz •
Parser •
Pascal •
Perl •
PHP •
PowerBASIC •
Python •
PL/1 •
Prolog •
R •
Ruby •
Scala •
Scheme •
Smalltalk •
SQL •
Standard ML •
PL/SQL •
Tcl •
Vala •
Visual Basic
(.NET)
 |
|  |
| Ուսումնական | 
Agda •
Clean •
Curry •
Լոգո •
ML •
REFAL •
Simula •
Օբերոն
 |
|  |
| IEC 61131-3 | 
Instruction List •
ST •
FBD •
Ladder Diagram (LD) •
SFC
 |
|  |
| Այլ | 
Modula-2 •
Miranda •
Hope •
Rexx
 |
|  |
| Էզոտերիկ | 
HQ9+/HQ9++ •
INTERCAL •
Brainfuck •
Brainfork •
Befunge •
Malbolge •
Piet •
Spoon •
Unlambda •
Whitespace •
FALSE •
LOLCODE
 |
|  |
| Վիզուալ | 
G
(LabVIEW) •
Microsoft VPL •
Sikuli •
VisSim •
Scratch
 |

 |