Standart Makine Öğrenimi - Standard ML
paradigma | Çoklu paradigma : işlevsel , zorunlu , modüler |
---|---|
Aile | makine öğrenimi |
İlk ortaya çıktı | 1983 |
kararlı sürüm | Standart ML '97 / 1997
|
Yazma disiplini | Çıkarsanmış , statik , güçlü |
Dosya adı uzantıları | .sml |
İnternet sitesi | sml ailesi |
Başlıca uygulamalar | |
SML/NJ , MLton | |
lehçeler | |
Alice , Eşzamanlı Makine Öğrenimi , Bağımlı Makine Öğrenimi | |
Tarafından etkilenmiş | |
ML , Umut , Pascal | |
Etkilenen | |
Karaağaç , F# , F* , Haskell , OCaml , Python , Rust , Scala |
Standart ML ( SML ), derleme zamanı tür denetimi ve tür çıkarımına sahip, genel amaçlı bir modüler işlevsel programlama dilidir. Bu arasında popüler derleyici yazar ve programlama dili araştırmacılar yanı sıra gelişiminde teoremi ispatlayıcılar .
Standart ML, Hesaplanabilir İşlevler için Mantık (LCF) teoremi kanıtlama projesinde kullanılan dil olan ML'nin modern bir lehçesidir . Sanki verilen resmi bir şartname sahip olmasıyla çok kullanılan dillerin arasında ayırt edicidir yazarak kuralları ve operasyonel semantik içinde Standart ML tanımı .
Dilim
Standard ML, bazı saf olmayan özelliklere sahip işlevsel bir programlama dilidir. Standart ML'de yazılan programlar , ifadeler veya komutlardan farklı olarak ifadelerden oluşur , ancak birim türündeki bazı ifadeler yalnızca yan etkileri için değerlendirilir .
Fonksiyonlar
Tüm işlevsel diller gibi, Standard ML'nin önemli bir özelliği de soyutlama için kullanılan işlevdir . Faktöriyel fonksiyon aşağıdaki gibi ifade edilebilir:
fun factorial n =
if n = 0 then 1 else n * factorial (n - 1)
Tür çıkarımı
Bir SML derleyicisi, kullanıcı tarafından sağlanan tür ek açıklamaları olmadan statik türü çıkarmalıdır. Bunun yalnızca tamsayı ifadeleriyle kullanıldığını ve bu nedenle kendisinin bir tamsayı olması gerektiğini ve tüm uçbirim ifadelerinin tamsayı ifadeleri olduğunu çıkarması gerekir.
val factorial : int -> int
n
bildirim tanımları
Aynı işlev , if - o zaman - else koşulunun belirli değerler için değerlendirilen faktöriyel işlevin şablonlarıyla değiştirildiği yan tümceli işlev tanımlarıyla ifade edilebilir :
fun factorial 0 = 1
| factorial n = n * factorial (n - 1)
Zorunlu tanımlar
veya yinelemeli olarak:
fun factorial n = let val i = ref n and acc = ref 1 in
while !i > 0 do (acc := !acc * !i; i := !i - 1); !acc
end
Lambda fonksiyonları
veya bir lambda işlevi olarak:
val rec factorial = fn 0 => 1 | n => n * factorial (n - 1)
Burada anahtar kelime val
tanıttı bir bir değere bir tanımlayıcı bağlanma, fn
bir tanıtır anonim işlev ve rec
kendini referans olmasını tanımını verir.
Yerel tanımlar
Burada görüldüğü gibi, değişmez-korumalı bir kuyruk özyinelemeli sıkı döngünün, bir veya daha fazla akümülatör parametresi ile sabit olmayan bir dış fonksiyon içinde kapsüllenmesi, Standart ML'de yaygın bir deyimdir.
Yerel bir işlev kullanılarak, daha verimli bir kuyruk özyinelemeli tarzda yeniden yazılabilir:
local
fun loop (0, acc) = acc
| loop (m, acc) = loop (m - 1, m * acc)
in
fun factorial n = loop (n, 1)
end
Eş anlamlıları yazın
Anahtar kelimeyle bir tür eşanlamlı tanımlanır type
. Burada bir düzlemdeki noktaların eşanlamlısı ve iki nokta arasındaki mesafeleri ve Heron formülüne göre verilen köşelere sahip bir üçgenin alanını hesaplayan fonksiyonlar verilmiştir . (Bu tanımlar sonraki örneklerde kullanılacaktır).
type loc = real * real
fun square (x : real) = x * x
fun dist (x, y) (x', y') =
Math.sqrt (square (x' - x) + square (y' - y))
fun heron (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
in
Math.sqrt (s * (s - x) * (s - y) * (s - z))
end
cebirsel veri türleri
Standart ML, cebirsel veri türleri (ADT) için güçlü destek sağlar . Bir veri türü, ayrı bir demet birliği (veya bir "ürün toplamı") olarak düşünülebilir . Büyük ölçüde kalıp eşleştirme ve çoğu Standart ML uygulamasının kalıp kapsamlılığı denetimi ve kalıp artıklığı denetimi nedeniyle tanımlamaları ve kullanımları kolaydır .
Nesne yönelimli programlama dillerinde, ayrık bir birlik, sınıf hiyerarşileri olarak ifade edilebilir . Ancak, sınıf hiyerarşilerinin aksine ADT'ler kapalıdır . Böylece ADT'lerin genişletilebilirliği, sınıf hiyerarşilerinin genişletilebilirliğine diktir. Sınıf hiyerarşileri, aynı arabirimi uygulayan yeni alt sınıflarla genişletilebilirken, ADT'lerin işlevselliği, sabit kurucu kümesi için genişletilebilir. Bkz. ifade sorunu .
Bir veri türü, anahtar kelimeyle şu şekilde tanımlanır datatype
:
datatype shape
= Circle of loc * real (* center and radius *)
| Square of loc * real (* upper-left corner and side length; axis-aligned *)
| Triangle of loc * loc * loc (* corners *)
Bir tür eşanlamlısının özyinelemeli olamayacağına dikkat edin; özyinelemeli kurucuları tanımlamak için veri türleri gereklidir. (Bu örnekte bu konu söz konusu değildir.)
desen eşleştirme
Desenler tanımlandıkları sırayla eşleştirilir. C programcıları, ML'nin veri türleri ve kalıp eşleştirme ile başardıklarını gerçekleştirmek için etiket değerlerine gönderme yapan etiketli sendikaları kullanabilir . Bununla birlikte, uygun kontrollerle donatılmış bir C programı, bir anlamda, ilgili ML programı kadar sağlam olacakken, bu kontroller zorunlu olarak dinamik olacaktır; ML'nin statik kontrolleri , derleme zamanında programın doğruluğu hakkında güçlü garantiler sağlar.
İşlev argümanları aşağıdaki gibi kalıplar olarak tanımlanabilir:
fun area (Circle (_, r)) = Math.pi * square r
| area (Square (_, s)) = square s
| area (Triangle p) = heron p (* see above *)
Argümanların kalıp olarak tanımlandığı işlev tanımının sözde "kelime biçimi", bir durum ifadesi için yalnızca sözdizimsel şekerdir :
fun area shape = case shape of
Circle (_, r) => Math.pi * square r
| Square (_, s) => square s
| Triangle p => heron p
Kapsamlılık kontrolü
Model kapsamlılık kontrolü, veri tipinin her kurucusunun en az bir modelle eşleşmesini sağlayacaktır.
Aşağıdaki model ayrıntılı değildir:
fun center (Circle (c, _)) = c
| center (Square ((x, y), s)) = (x + s / 2.0, y + s / 2.0)
Hiçbir desen yoktur Triangle
davanın center
fonksiyonu. Derleyici, case ifadesinin ayrıntılı olmadığı konusunda bir uyarı verir ve Triangle
çalışma zamanında bu işleve a geçirilirse, yükseltilir.
exception Match
Artıklık kontrolü
Aşağıdaki (anlamsız) işlevin ikinci tümcesindeki kalıp gereksizdir:
fun f (Circle ((x, y), r)) = x + y
| f (Circle _) = 1.0
| f _ = 0.0
İkinci fıkradaki kalıpla eşleşen herhangi bir değer, birinci fıkradaki kalıpla da eşleşir, bu nedenle ikinci fıkraya ulaşılamaz. Bu nedenle, bu tanım bir bütün olarak fazlalık sergiler ve derleme zamanı uyarısına neden olur.
Aşağıdaki işlev tanımı ayrıntılıdır ve gereksiz değildir:
val hasCorners = fn (Circle _) => false | _ => true
Kontrol ilk kalıbı ( Circle
) geçerse , şeklin a Square
veya a olması gerektiğini biliyoruz Triangle
. Her iki durumda da şeklin köşeleri olduğunu biliyoruz, bu nedenle true
gerçek şekli ayırt etmeden geri dönebiliriz .
Üst düzey işlevler
İşlevler, işlevleri bağımsız değişken olarak tüketebilir:
fun map f (x, y) = (f x, f y)
İşlevler, dönüş değerleri olarak işlevler üretebilir:
fun constant k = (fn _ => k)
İşlevler ayrıca işlevleri hem tüketebilir hem de üretebilir:
fun compose (f, g) = (fn x => f (g x))
Fonksiyon List.map
baz kütüphanesinden standart ML en yaygın olarak kullanılan daha yüksek dereceden fonksiyonları biridir:
fun map _ [] = []
| map f (x :: xs) = f x :: map f xs
tail-recursive ile daha verimli bir uygulama List.foldl
:
fun map f = List.rev o List.foldl (fn (x, acc) => f x :: acc) []
istisnalar
İstisnalar anahtar kelimeyle ortaya çıkar raise
ve kalıp eşleştirme handle
yapısıyla işlenir . İstisna sistemi, yerel olmayan çıkış uygulayabilir ; bu optimizasyon tekniği aşağıdaki gibi işlevler için uygundur.
exception Zero;
fun prod xs = let
fun p (0 :: _) = raise Zero
| p (h :: t) = h * p t
| p [] = 1
in
p xs handle Zero => 0
end
Ne zaman yükseltilir, kontrol fonksiyonunu bırakır tamamen. Alternatifi düşünün: 0 değeri en son bekleyen çerçeveye döndürülecek, yerel değeriyle çarpılacak , elde edilen değer (kaçınılmaz olarak 0) bir sonraki bekleyen çerçeveye döndürülecek, vb. İstisnanın yükseltilmesi, kontrolün tüm çerçeve zinciri üzerinde sıçramasına ve ilgili hesaplamadan kaçınmasına izin verir. Alt çizginin ( ) joker karakter olarak kullanıldığına dikkat edin .
exception Zero
p
h
_
Aynı optimizasyonun bir tail call ile de elde edilebileceği belirtilmelidir .
local
fun p a (0 :: _) = 0
| p a (x :: xs) = p (a * x) xs
| p a [] = a
in
val prod = p 1
end
Modül sistemi
Standart ML'nin gelişmiş modül sistemi, programların mantıksal olarak ilişkili tür ve değer tanımlarının hiyerarşik olarak organize edilmiş yapılarına ayrıştırılmasına olanak tanır . Modüller yalnızca ad alanı denetimi sağlamakla kalmaz , aynı zamanda soyut veri türlerinin tanımlanmasına izin vermeleri anlamında soyutlama da sağlar . Modül sistemini üç ana sözdizimsel yapı oluşturur: imzalar, yapılar ve işlevler.
imzalar
Bir imza bir bir arayüz genellikle bir yapı için bir tip olarak düşünülebilir; o yapının yanı sıra tarafından sağlanan tüm varlıkların adlarını belirtir Arity her tür bileşen, her değer bileşenin türüne ve her altyapının imza. Tip bileşenlerinin tanımları isteğe bağlıdır; tanımları gizli olan tür bileşenleri soyut türlerdir .
Örneğin, bir kuyruğun imzası şöyle olabilir:
signature QUEUE = sig
type 'a queue
exception QueueError;
val empty : 'a queue
val isEmpty : 'a queue -> bool
val singleton : 'a -> 'a queue
val fromList : 'a list -> 'a queue
val insert : 'a * 'a queue -> 'a queue
val peek : 'a queue -> 'a
val remove : 'a queue -> 'a * 'a queue
end
Bu imza, bir polimorfik tipi sağlayan bir modülü anlatmaktadır , ve sıraları ile ilgili temel işlemleri tanımlayan değerleri.
'a queue
exception QueueError
Yapılar
Bir yapı bir modüldür; mantıksal bir birimde paketlenmiş türler, istisnalar, değerler ve yapılar ( altyapılar olarak adlandırılır ) koleksiyonundan oluşur .
Bir kuyruk yapısı aşağıdaki gibi uygulanabilir:
structure TwoListQueue :> QUEUE = struct
type 'a queue = 'a list * 'a list
exception QueueError;
val empty = ([], [])
fun isEmpty ([], []) = true
| isEmpty _ = false
fun singleton a = ([], [a])
fun fromList a = ([], a)
fun insert (a, ([], [])) = singleton a
| insert (a, (ins, outs)) = (a :: ins, outs)
fun peek (_, []) = raise QueueError
| peek (ins, outs) = List.hd outs
fun remove (_, []) = raise QueueError
| remove (ins, [a]) = (a, ([], List.rev ins))
| remove (ins, a :: outs) = (a, (ins, outs))
end
Bu tanım, uyguladığını bildirir . Bundan başka, opak üstüne atma ile gösterilen imza (yani tanımlı olmayan herhangi bir tür olduğu durumları ) listeleri, bir çift olarak bir sıra tanımı dışında görünür modülü değildir, yani özet olmalıdır. Yapı, imzadaki tüm tanımları uygular.
structure TwoListQueue
signature QUEUE
:>
type 'a queue
Bir yapıdaki türlere ve değerlere "nokta notasyonu" ile erişilebilir:
val q : string TwoListQueue.queue = TwoListQueue.empty
val q' = TwoListQueue.insert (Real.toString Math.pi, q)
işlevler
Bir funktor yapılarına yapılardan bir fonksiyonudur; yani bir işlev, genellikle belirli bir imzanın yapıları olan bir veya daha fazla argümanı kabul eder ve sonuç olarak bir yapı üretir. İşlevler, genel veri yapılarını ve algoritmaları uygulamak için kullanılır .
Ağaçların enine önce aranması için popüler bir algoritma , kuyrukları kullanır. Burada bu algoritmanın soyut bir kuyruk yapısı üzerinde parametrelendirilmiş bir versiyonunu sunuyoruz:
(* after Okasaki, ICFP, 2000 *)
functor BFS (Q: QUEUE) = struct
datatype 'a tree = E | T of 'a * 'a tree * 'a tree
local
fun bfsQ q = if Q.isEmpty q then [] else search (Q.remove q)
and search (E, q) = bfsQ q
| search (T (x, l, r), q) = x :: bfsQ (insert (insert q l) r)
and insert q a = Q.insert (a, q)
in
fun bfs t = bfsQ (Q.singleton t)
end
end
structure QueueBFS = BFS (TwoListQueue)
İçinde , kuyruğun temsilinin görünmediğini unutmayın. Daha somut olarak, eğer gerçekten kullanılan temsil buysa, iki liste kuyruğundaki ilk listeyi seçmenin bir yolu yoktur. Bu veri soyutlama mekanizması, genişlik öncelikli aramayı kuyruğun uygulanması için gerçekten agnostik hale getirir. Bu genel olarak arzu edilir; bu durumda, kuyruk yapısı, doğruluğunun kurşun geçirmez soyutlama duvarının arkasında bağlı olduğu herhangi bir mantıksal değişmezi güvenle koruyabilir.
functor BFS
Kod örnekleri
SML kodunun parçacıkları en kolay şekilde etkileşimli bir üst seviyeye girilerek incelenebilir .
Selam Dünya
Aşağıda bir Merhaba dünya! program:
merhaba.sml |
---|
print "Hello, world!\n"
|
bash |
$ mlton hello.sml
$ ./hello
Hello, world!
|
algoritmalar
Ekleme sıralama
(artan) için eklemeli sıralama kısaca şu şekilde ifade edilebilir:
int list
fun insert (x, []) = [x] | insert (x, h :: t) = sort x (h, t)
and sort x (h, t) = if x < h then [x, h] @ t else h :: insert (x, t)
val insertionsort = List.foldl insert []
birleştirilmiş
Burada klasik mergesort algoritması üç işlevde uygulanır: split, merge ve mergesort. Ayrıca, sözdizimi dışında ve listeleri ifade eden türlerin bulunmadığına da dikkat edin . Bu kod, tutarlı bir sıralama işlevi tanımlandığı sürece her türden listeyi sıralayacaktır . Hindley–Milner tipi çıkarımı kullanarak , fonksiyon gibi karmaşık türler dahil tüm değişkenlerin türleri çıkarılabilir .
op ::
[]
cmp
cmp
Bölmek
fun split
bir ile uygulanan durum bilgisi kapağın olan vekilleri arasında true
ve false
, giriş göz ardı:
fun alternator {} = let val state = ref true
in fn a => !state before state := not (!state) end
(* Split a list into near-halves which will either be the same length,
* or the first will have one more element than the other.
* Runs in O(n) time, where n = |xs|.
*)
fun split xs = List.partition (alternator {}) xs
Birleştirmek
Birleştirme, verimlilik için yerel bir işlev döngüsü kullanır. İç loop
, durumlar açısından tanımlanır: her iki liste de boş olmadığında ( ) ve bir liste boş olduğunda ( ).
x :: xs
[]
Bu işlev, iki sıralı listeyi tek bir sıralanmış listede birleştirir. Akümülatörün acc
geriye doğru nasıl kurulduğuna ve geri gönderilmeden önce nasıl tersine çevrildiğine dikkat edin. Bu yaygın bir tekniktir, çünkü bağlantılı bir liste olarak temsil edilir ; bu teknik daha fazla saat süresi gerektirir, ancak asimptotikler daha kötü değildir.
'a list
(* Merge two ordered lists using the order cmp.
* Pre: each list must already be ordered per cmp.
* Runs in O(n) time, where n = |xs| + |ys|.
*)
fun merge cmp (xs, []) = xs
| merge cmp (xs, y :: ys) = let
fun loop (a, acc) (xs, []) = List.revAppend (a :: acc, xs)
| loop (a, acc) (xs, y :: ys) =
if cmp (a, y)
then loop (y, a :: acc) (ys, xs)
else loop (a, y :: acc) (xs, ys)
in
loop (y, []) (ys, xs)
end
birleştirilmiş
Ana işlev:
fun ap f (x, y) = (f x, f y)
(* Sort a list in according to the given ordering operation cmp.
* Runs in O(n log n) time, where n = |xs|.
*)
fun mergesort cmp [] = []
| mergesort cmp [x] = [x]
| mergesort cmp xs = (merge cmp o ap (mergesort cmp) o split) xs
Hızlı sıralama
Quicksort aşağıdaki gibi ifade edilebilir. bir sipariş işlecini tüketen bir kapatmadır .
fun part
op <<
infix <<
fun quicksort (op <<) = let
fun part p = List.partition (fn x => x << p)
fun sort [] = []
| sort (p :: xs) = join p (part p xs)
and join p (l, r) = sort l @ p :: sort r
in
sort
end
ifade yorumlayıcısı
Küçük bir ifade dilinin tanımlanıp işlenebileceği göreceli kolaylığa dikkat edin:
exception TyErr;
datatype ty = IntTy | BoolTy
fun unify (IntTy, IntTy) = IntTy
| unify (BoolTy, BoolTy) = BoolTy
| unify (_, _) = raise TyErr
datatype exp
= True
| False
| Int of int
| Not of exp
| Add of exp * exp
| If of exp * exp * exp
fun infer True = BoolTy
| infer False = BoolTy
| infer (Int _) = IntTy
| infer (Not e) = (assert e BoolTy; BoolTy)
| infer (Add (a, b)) = (assert a IntTy; assert b IntTy; IntTy)
| infer (If (e, t, f)) = (assert e BoolTy; unify (infer t, infer f))
and assert e t = unify (infer e, t)
fun eval True = True
| eval False = False
| eval (Int n) = Int n
| eval (Not e) = if eval e = True then False else True
| eval (Add (a, b)) = (case (eval a, eval b) of (Int x, Int y) => Int (x + y))
| eval (If (e, t, f)) = eval (if eval e = True then t else f)
fun run e = (infer e; SOME (eval e)) handle TyErr => NONE
İyi yazılmış ve kötü yazılmış ifadelerde örnek kullanım:
val SOME (Int 3) = run (Add (Int 1, Int 2)) (* well-typed *)
val NONE = run (If (Not (Int 1), True, False)) (* ill-typed *)
Keyfi kesinlikli tamsayılar
IntInf
Modül aritmetik tamsayıdır keyfi kesinlik sağlar. Ayrıca, tamsayı değişmezleri, programcının herhangi bir şey yapmasına gerek kalmadan keyfi kesinlikli tamsayılar olarak kullanılabilir.
Aşağıdaki program, isteğe bağlı kesinlikte bir faktöriyel işlevi uygular:
gerçek.sml |
---|
fun fact n : IntInf.int = if n = 0 then 1 else n * fact (n - 1);
fun printLine str = let in
TextIO.output (TextIO.stdOut, str);
TextIO.output (TextIO.stdOut, "\n")
end;
val () = printLine (IntInf.toString (fact 120));
|
bash |
$ mlton fact.sml
$ ./fact
6689502913449127057588118054090372586752746333138029810295671352301
6335572449629893668741652719849813081576378932140905525344085894081
21859898481114389650005964960521256960000000000000000000000000000
|
Kısmi uygulama
Curried fonksiyonların, fazlalık kodu ortadan kaldırmak gibi pek çok uygulaması vardır. Örneğin, bir modül türünde işlevler gerektirebilir , ancak tür ve nesneler arasında sabit bir ilişkinin olduğu türde işlevler yazmak daha uygundur . Bir tür işlevi, bu ortaklığın çarpanlarına ayırabilir. Bu, adaptör modelinin bir örneğidir .
a -> b
a * c -> b
a
c
c -> (a * c -> b) -> a -> b
Bu örnekte, verilen bir fonksiyonun nümerik türevini şu noktada hesaplar :
fun d
f
x
- fun d delta f x = (f (x + delta) - f (x - delta)) / (2.0 * delta)
val d = fn : real -> (real -> real) -> real -> real
type , type ile bir işleve bir "float" eşlediğini gösterir . Bu, körleme olarak bilinen argümanları kısmen uygulamamıza izin verir . Bu durumda işlev , kısmen argümanla uygulanarak özelleştirilebilir . Bu algoritmayı kullanırken epsilon makinesinin küp kökü iyi bir seçimdir .
fun d
(real -> real) -> real -> real
d
delta
delta
- val d' = d 1E~8;
val d' = fn : (real -> real) -> real -> real
Çıkarsanan türün , ilk bağımsız değişkeni olarak d'
türe sahip bir işlev beklediğini belirttiğine dikkat edin . Bu türev bir yaklaşma hesaplayabilir de . Doğru cevap .
real -> real
- d' (fn x => x * x * x - x - 1.0) 3.0;
val it = 25.9999996644 : real
Kütüphaneler
Standart
Temel kitaplık standartlaştırılmıştır ve çoğu uygulama ile birlikte gönderilir. Ağaçlar, diziler ve diğer veri yapıları için modüllerin yanı sıra giriş/çıkış ve sistem arayüzleri sağlar.
Üçüncü parti
Sayısal hesaplama için bir Matrix modülü mevcuttur (ancak şu anda bozuktur), https://www.cs.cmu.edu/afs/cs/project/pscico/pscico/src/matrix/README.html .
Grafikler için, cairo-sml, Kahire grafik kitaplığına açık kaynaklı bir arayüzdür . Makine öğrenimi için grafik modeller için bir kitaplık mevcuttur.
Uygulamalar
Standart ML'nin uygulamaları aşağıdakileri içerir:
Standart
- HaMLet : standardın doğru ve erişilebilir bir referans uygulaması olmayı amaçlayan bir Standart ML yorumlayıcısı
- MLton ( mlton.org ): Tanıma sıkı sıkıya uyan ve LLVM ve C için arka uçlar dahil olmak üzere diğer ML uygulamalarına kıyasla çok hızlı kod üreten bir tam program optimize edici derleyici
- Moscow ML : Modüller ve temel kitaplığın çoğu dahil olmak üzere tam Standart ML dilini uygulayan CAML Light çalışma zamanı motorunu temel alan hafif bir uygulama
- Poly/ML : Hızlı kod üreten ve çok çekirdekli donanımı (Posix iş parçacıkları aracılığıyla) destekleyen tam bir Standart ML uygulaması; çalışma zamanı sistemi, paralel çöp toplama ve değişmez altyapıların çevrimiçi paylaşımını gerçekleştirir.
- New Jersey Standart ML ( smlnj.org ): ilişkili kitaplıklar, araçlar, etkileşimli bir kabuk ve Concurrent ML desteğine sahip belgelerle birlikte tam bir derleyici
- SML.NET : bir standart ML derleyici ortak dil çalışma zamanı diğeriyle bağlantı için uzantılara sahip .NET kodu
- ML Kit : Gerçek zamanlı uygulamaları desteklemeyi amaçlayan , bir çöp toplayıcı (devre dışı bırakılabilen) ve bölge tabanlı bellek yönetimini otomatik bölge çıkarımı ile entegre eden Tanım'a çok yakın bir uygulama
Türev
- Alice : Saarland Üniversitesi'nden Standart ML için vadeli işlemler , tembel değerlendirme , uzaktan prosedür çağrıları ve kısıtlama programlama yoluyla dağıtılmış bilgi işlem kullanan paralel programlama desteğine sahip bir tercüman
- SML# : kayıt polimorfizmi ve C dili birlikte çalışabilirliği sağlayan bir SML uzantısı. Bu, geleneksel bir yerel derleyicidir ve adı, .NET çerçevesi üzerinde çalışmak için bir ima değildir.
- SOSML : bir uygulama ile yazılmış typescript temeli kütüphanesinin SML dilinin en basıp parçaları destekleyen
Araştırma
- CakeML , resmi olarak doğrulanmış çalışma zamanı ve montajcıya çeviri ile ML'nin bir REPL sürümüdür.
- Isabelle ( Isabelle / ML ) bütünleştirir (dayanarak karmaşık IDE ile interaktif bir teoremi prover içine Poly / ML paralel JEdit resmi Standart ML (SML'97) Isabelle / ML lehçesi ve prova dil için). Isabelle2016 ile başlayarak, makine öğrenimi için kaynak düzeyinde bir hata ayıklayıcı da vardır.
- Poplog , Common Lisp ve Prolog ile birlikte Standart ML'nin bir sürümünü uygulayarak karma dil programlamaya izin verir; tümü , aşamalı olarak derlenen POP-11'de uygulanır .
- TILT kullandığı daktilo Standart ML için tam sertifika derleyici olduğu ara dilleri için optimize kod ve doğruluğunu sağlamak ve derlemek olabilir Yazılan birleştirici dili .
Bu uygulamaların tümü açık kaynaklıdır ve ücretsiz olarak kullanılabilir. Çoğu, Standart ML'de uygulanır. Artık herhangi bir ticari uygulama yoktur; Harlequin , şimdi feshedilmiş, bir zamanlar ticari bir IDE ve MLWorks adlı derleyici üretti ve bu, Xanalys'e geçti ve daha sonra 26 Nisan 2013'te Ravenbrook Limited tarafından satın alındıktan sonra açık kaynaklı oldu.
SML kullanan büyük projeler
Kopenhag IT Üniversitesi 'nin tüm kurumsal mimari personel kayıtları, bordro, ders yönetimi ve geri bildirim, öğrenci proje yönetimi ve web tabanlı self-servis arayüzleri dahil SML yaklaşık 100.000 hatları, uygulanmaktadır.
Geçirmez yardımcıları HOL4 , Isabelle , LEGO ve Twelf Standart ML yazılmıştır. Ayrıca derleyici yazarları ve ARM gibi entegre devre tasarımcıları tarafından da kullanılır .
Ayrıca bakınız
Referanslar
- ^ a b "Standart ML'de Programlama: Hiyerarşiler ve Parametreleştirme" . 2020-02-22 alındı .
- ^ a b c "SML '97" . www.smlnj.org .
- ^ a b "itertools — Verimli döngü için yineleyiciler oluşturan işlevler — Python 3.7.1rc1 belgeleri" . docs.python.org .
- ^ a b Robin Milner; Mads Tofte; Robert Harper; David MacQueen (1997). Standart ML'nin Tanımı (Revize) . MİT Basın. ISBN'si 0-262-63181-4.
- ^ a b Chris Okasaki (2000). "Genişlik-İlk Numaralandırma: Algoritma Tasarımında Küçük Bir Alıştırmadan Dersler". Uluslararası Fonksiyonel Programlama Konferansı 2000 . ACM.
- ^ a b Mads Tofte. "Standart ML dili" . Scholarpedia . 2020-01-08 alındı .
- ^ a b Yeşim Alglave; Anthony CJ Fox; Samin Ishtiaq; Magnus O. Myreen; Susmit Sarkar; Peter Sewell; Francesco Zappa Nardelli. Güç ve ARM Çok İşlemcili Makine Kodunun Anlamı (PDF) . DAMP 2009. s. 13–24.
Dış bağlantılar
Standart Makine Öğrenimi Hakkında
halef ML hakkında
- ardıl ML (sML) : Başlangıç noktası olarak Standart ML kullanan ML'nin evrimi
- GitHub'da HaMLet : halef ML için referans uygulaması
Pratik
Akademik