സ്റ്റാൻഡേർഡ് എംഎൽ

**സ്റ്റാൻഡേർഡ് എംഎൽ** (SML; "സ്റ്റാൻഡേർഡ് മെറ്റാ ലാംഗ്വേജ്") ഒരു പൊതുവായ ഉദ്ദേശ്യവും, മോഡുലാർ, ഫംഗ്ഷണൽ പ്രോഗ്രാമിങ് ഭാഷയും, കംപൈൽ ടൈം ടൈപ്പ് പരിശോധന, ടൈപ്പ് ഇൻഫ്രൻസ് എന്നിവയാണ്. കംപൈലർ രചയിതാക്കളും പ്രോഗ്രാമിങ് ഭാഷയിലെ ഗവേഷകർക്ക് വേണ്ടിയും, അതുപോലെതന്നെ തീയറം പ്രൂവേഴ്സിന്റെ വികസനവും ഇതിൽ ഉൾപ്പെടുന്നു.

ലോജിക്കൽ ഫോർ കംമ്പ്യൂട്ടബിൾ ഫംഗ്ഷൻ (എൽസിഎഫ്) സിദ്ധാന്തം തെളിയിക്കുന്ന പ്രോജക്ടിൽ ഉപയോഗിച്ചിരുന്ന പ്രോഗ്രാമിങ് ഭാഷ എം.എൽ. യുടെ ഒരു ആധുനിക ഭാഷാഭേദിയാണ് എസ്എംഎൽ. വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്ന ഭാഷകളിൽ ഇത് ഒരു പ്രത്യേക നിർവചനമാണ്, സ്റ്റാൻഡേർഡ് എംഎല്ലിന്റെ നിർവ്വചനത്തിൽ ടൈപ്പിങ് നിയമങ്ങളും പ്രവർത്തനപരമായ സെമാന്റിക്സും നൽകിയിരിക്കുന്നു, (1990,  ദി സ്റ്റാൻഡേർഡ് എംഎൽ (പരിഷ്ക്കരിച്ച പതിപ്പ്)പരിഷ്കരിച്ചതും ലളിതവൽക്കരിച്ചതും 1997 ലാണ്.)
## ഭാഷ
സ്റ്റാൻഡേർഡ് എം എൽ ആണ് ചില കലർപ്പുള്ള(impure) സവിശേഷതകൾ ഉള്ള ഒരു പ്രവർത്തന പ്രോഗ്രാമിങ് ഭാഷയാണ്. സ്റ്റാൻഡേർഡ് എം.എല്ലിൽ എഴുതപ്പെട്ട പ്രോഗ്രാമുകൾ, പ്രസ്താവനകൾക്കോ ആജ്ഞകൾക്കോ എതിരായി, ചില എക്സ്പ്രഷനുകൾ അസാധാരണമായ "യൂണിറ്റ്" മൂല്യത്തെ മടക്കി കൊണ്ടുപോവുകയും അവയുടെ സൈഡ് ഇഫക്റ്റുകൾ മാത്രം വിലയിരുത്തുകയും ചെയ്യുന്നു. എല്ലാ പ്രവർത്തന പ്രോഗ്രാമിങ് ഭാഷകളെ പോലെ, സ്റ്റാൻഡേർഡ് എംഎല്ലിന്റെ ഒരു പ്രധാന സവിശേഷതയാണ് അമൂർത്തീകരണത്തിന്(abstraction) ഉപയോഗിക്കുന്നത്. ഉദാഹരണത്തിന്, ഫാക്റ്റോറിയൽ പ്രവർത്തനം ഇങ്ങനെ പ്രകടിപ്പിക്കാം:

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

സ്റ്റാറ്റിക് തരം അനുമാനിക്കാൻ ഒരു സ്റ്റാൻഡേർഡ് എം എൽ കമ്പൈലർ ആവശ്യമാണ്, int -> int  ഈ യൂസർ സപ്ലൈ ചെയ്തതോ ആയ തരം വ്യാഖ്യാനങ്ങൾ ഇല്ലാത്തതാണ്. അതായത്, ആ സംഖ്യയെ പൂർണ്ണസംഖ്യകളായി മാത്രമേ ഉപയോഗിക്കാവൂ, അതിനാൽ തന്നെ ഒരു പൂർണ്ണസംഖ്യയായിരിക്കണം കൂടാതെ ഫങ്ഷൻ റിട്ടേൺ ഇൻജേർഡേഴ്സിലെ എല്ലാ മൂല്യനിർണ്ണയ എക്സ്പ്രഷനുകളും ഉണ്ടായിരിക്കണം. ഒരേ ഫങ്ഷൻ ഘടകം ഫങ്ഷൻ നിർവ്വചനങ്ങളാൽ പ്രകടമാവുന്നവയാണെങ്കിൽ, if-then-else conditional മാറ്റിസ്ഥാപിക്കപ്പെടുന്ന ഫാക്റ്റോറിയൽ പ്രവർത്തനത്തിന്റെ ടെംപ്ലേറ്റുകൾ നിന്ന് ഒരു ശ്രേണിയെ മാറ്റി നിർത്തുന്നത് വേർതിരിച്ചറിയാൻ '|', എന്ന ചിഹ്നം ഉപയോഗിച്ച് വേർതിരിച്ചെടുക്കുന്നത് ഒരു പൊരുത്തം കണ്ടെത്തുന്നതുവരെ എഴുതിയിരിക്കുന്ന ക്രമത്തിൽ ഒരെണ്ണം പരീക്ഷിച്ചുനോക്കുന്നു:

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

ഇതുപോലുള്ള ഒരു കേസ് പ്രസ്താവന ഉപയോഗിച്ച് ഇത് തിരുത്തിയെഴുതാൻ കഴിയും:

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

അല്ലെങ്കിൽ ആവർത്തിച്ച് വരുന്നത്:

```sml
fun factorialIT value =
let
  val flag = ref value and i = ref 1
in
  while !flag <> 0 do (
  i := !i * !flag;
  flag := !flag - 1
  );
  !i
end;
```

അല്ലെങ്കിൽ ഒരു ലാമ്പ്ഡാ ഫംഗ്ഷൻ:

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

ഇവിടെ, കീവേഡ് `val` ഒരു മൂല്യത്തേക്കുള്ള ഐഡന്റിഫയറിന്റെ ഒരു ബിൻഡിനെ പരിചയപ്പെടുത്തുന്നു, ഒരു അജ്ഞാത ഫംഗ്ഷന്റെ നിർവ്വചനം `fn` അവതരിപ്പിക്കുന്നു, കൂടാതെ `case` പാറ്റേണുകളുടെയും അനുബന്ധ എക്സ്പ്രഷനുകളുടെയും ഒരു ക്രമം പരിചയപ്പെടുത്തുന്നു. ഒരു പ്രാദേശിക ഫങ്ഷൻ ഉപയോഗിച്ച്, ഈ ഫംഗ്ഷൻ കൂടുതൽ കാര്യക്ഷമമായ ടേയിൽ(tail) പുനർക്രമീകരണ രീതിയിൽ തിരുത്താവുന്നതാണ്.

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

(ലെറ്റ്-എക്സ്പ്രഷന്റെ മൂല്യം എക്സ്പ്രഷനും അതിന്റെ അവസാനവും തമ്മിലുള്ള ആവിഷ്ക്കാരമാണ്.) ഒരു അന്തർലീനമില്ലാത്ത സ്വതന്ത്ര ബാഹ്യ പ്രവർത്തനത്തിനുള്ളിൽ ഒന്നോ അതിലധികമോ ശേഖരിക്കൽ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഒരു മാറ്റമില്ലാത്ത-പരിരക്ഷിക്കുന്ന ടെയിൽ-റിക്കർഷൻ ട‌ൈപ്പ് ലൂപ്പ്, ഇവിടെ കാണപ്പെടുന്നതുപോലെ, സ്റ്റാൻഡേർഡ് എം.എൽ(ML) ഒരു സാധാരണ ഭാഷാരീതി(idiom) ആണ്, കൂടാതെ എസ്എംഎൽ(SML) കോഡിലെ വലിയ ആവൃത്തിയിൽ പ്രത്യക്ഷപ്പെടുകയും ചെയ്യുന്നു.
### ടൈപ്പ് സിനോണിമസ്
ടൈപ്പ് കീവേഡിനൊപ്പം ടൈപ്പ് സിനോണിമസ് നിർവചിക്കപ്പെടുന്നു. ഒരു പ്രതത്തിലുളള പോയിന്റുകൾക്കായി ഒരു ടൈപ്പ് പര്യായപദം ഇവിടെയുണ്ട്, രണ്ട് പോയിന്റുകൾ തമ്മിലുള്ള ദൂരവും, ഹെറോണുകളുടെ ഫോർമുല അനുസരിച്ച് തന്നിരിക്കുന്ന പരിധികളിൽ ഒരു ത്രികോണത്തിന്റെ വിസ്തൃതിയും കണക്കാക്കുന്നു. (ഈ നിർവചനങ്ങൾ തുടർന്നുള്ള ഉദാഹരണങ്ങളിൽ ഉപയോഗിക്കും).

```sml
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
```

### ആൾജിബ്രേയ്ക് ഡേറ്റ തരങ്ങളും പാറ്റേൺ പൊരുത്തപ്പെടലും
ബീജഗണിതമായ ഡാറ്റാടൈപ്പുകൾക്ക് ശക്തമായ പിന്തുണ നൽകിക്കൊണ്ട് സ്റ്റാൻഡേർഡ് എംഎൽ സഹായിക്കുന്നു. ഒരു എം.എൽ. ഡാറ്റാടൈപ്പ് ടപ്പിൾസിന്റെ ഒരു വിയോജന യൂണിയനായി കണക്കാക്കാം (അല്ലെങ്കിൽ ഒരു "ഗുണനഫലങ്ങളുടെ തുക"). അവ വിശദീകരിക്കാൻ എളുപ്പമാണ് മാത്രമല്ല പ്രോഗ്രാം ചെയ്യാൻ എളുപ്പവും, സ്റ്റാൻഡേർഡ് എംഎല്ലിന്റെ വലിയ ഭാഗം പാറ്റേൺ പൊരുത്തപ്പെടുന്നതിനാൽ സ്റ്റാൻഡേർഡ് എം.എൽ.പ്രവർത്തികളും 'പാറ്റേൺ എക്സ്ഹോസ്റ്റീവ്നെസ്സ് പരിശോധനയും പാറ്റേൺ വ്യർത്ഥ സ്ഥൂലതാ പരിശോധനയും നടത്തുന്നു.

## അവലംബം