لغة الآلة القياسية

كما هو الحال في جميع اللغات الوظيفية، فإن إحدى السمات الرئيسية للغة Standard ML هي الدالة ، التي تُستخدم للتجريد. ويمكن التعبير عن دالة المضروب كما يلي:

دالة مضروب n = إذا كان n = 0 فإن 1 وإلا n * مضروب ( n - 1 )

يجب على مُصرّف لغة SML استنتاج النوع الثابت دون الحاجة إلى تعليقات توضيحية للأنواع من قِبل المستخدم. عليه أن يستنتج أن هذا النوع يُستخدم فقط مع التعبيرات العددية الصحيحة، وبالتالي يجب أن يكون هو نفسه عددًا صحيحًا، وأن جميع التعبيرات الطرفية هي تعبيرات عددية صحيحة.valfactorial:int->intn

يمكن التعبير عن نفس الوظيفة باستخدام تعريفات الوظائف الشرطية حيث يتم استبدال الشرط if - then - else بقوالب لدالة المضروب التي يتم تقييمها لقيم محددة:

دالة مضروب 0 = 1 | مضروب n = n * مضروب ( n - 1 )

أو بشكل متكرر:

دالة حساب المضروب n = let val i = ref n and acc = ref 1 in while !i > 0 do ( acc := !acc * !i ; i := !i - 1 ); !acc end

أو كدالة لامدا:

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

هنا، تُدخل الكلمة المفتاحية valربطًا بين مُعرّف وقيمة، fnوتُدخل دالة مجهولة ، recوتسمح بأن يكون التعريف مرجعيًا ذاتيًا.

إن تغليف حلقة تكرارية ضيقة تحافظ على الثابت مع معلمات تراكمية واحدة أو أكثر داخل دالة خارجية خالية من الثابت، كما هو موضح هنا، هو أسلوب شائع في لغة ML القياسية.

باستخدام دالة محلية، يمكن إعادة كتابتها بأسلوب أكثر كفاءة يعتمد على الاستدعاء الذاتي الذيل:

دالة محلية loop ( 0 , acc ) = acc | loop ( m , acc ) = loop ( m - 1 , m * acc ) في دالة factorial n = loop ( n , 1 ) نهاية

يُعرَّف مرادف النوع باستخدام الكلمة المفتاحية type. فيما يلي مرادف نوع للنقاط على مستوى ، ودوال لحساب المسافات بين نقطتين، ومساحة مثلث ذي زوايا معينة وفقًا لصيغة هيرون . (ستُستخدم هذه التعريفات في الأمثلة اللاحقة).

نوع الموقع = حقيقي * حقيقيدالة المربع ( س : عدد حقيقي ) = س * سدالة المسافة ( س ، ص ) ( س' ، ص' ) = جذر ( مربع ( س ' - س ) + مربع ( ص' - ص ) )دالة هيرون ( أ ، ب ، ج ) = 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​

توفر لغة Standard ML دعمًا قويًا لأنواع البيانات الجبرية (ADT). يمكن اعتبار نوع البيانات اتحادًا منفصلاً من الصفوف (أو "مجموع حاصل الضرب"). تتميز هذه الأنواع بسهولة تعريفها واستخدامها، ويعود ذلك بشكل كبير إلى مطابقة الأنماط ، بالإضافة إلى فحص شمولية الأنماط وفحص تكرارها في معظم تطبيقات Standard ML .

في لغات البرمجة كائنية التوجه ، يمكن التعبير عن الاتحاد المنفصل باستخدام تسلسلات هرمية للفئات . مع ذلك، وعلى عكس التسلسلات الهرمية للفئات ، فإن أنواع البيانات المجردة (ADTs) مغلقة . وبالتالي، فإن قابلية توسيع أنواع البيانات المجردة مستقلة عن قابلية توسيع التسلسلات الهرمية للفئات. يمكن توسيع التسلسلات الهرمية للفئات بإضافة فئات فرعية جديدة تُنفذ نفس الواجهة، بينما يمكن توسيع وظائف أنواع البيانات المجردة لمجموعة ثابتة من المُنشئات. انظر مسألة التعبير .

يتم تعريف نوع البيانات باستخدام الكلمة المفتاحية datatype، كما في:

datatype shape = دائرة من loc * real (* المركز ونصف القطر *) | مربع من loc * real (* الزاوية العلوية اليسرى وطول الضلع؛ محاذي للمحور *) | مثلث من loc * loc * loc (* الزوايا *)

لاحظ أن مرادف النوع لا يمكن أن يكون تكراريًا؛ فأنواع البيانات ضرورية لتعريف المُنشئات التكرارية. (هذا ليس محل نقاش في هذا المثال).

تُطابق الأنماط بالترتيب الذي عُرّفت به. يستطيع مبرمجو لغة C استخدام الاتحادات الموسومة ، والتوزيع بناءً على قيم الوسوم، للقيام بما تفعله لغة ML مع أنواع البيانات ومطابقة الأنماط. مع ذلك، فبينما سيكون برنامج C المُزوّد ​​بفحوصات مناسبة، من ناحية ما، بنفس قوة برنامج ML المقابل، ستكون هذه الفحوصات ديناميكية بالضرورة؛ إذ توفر الفحوصات الثابتة في ML ضمانات قوية حول صحة البرنامج في وقت الترجمة.

يمكن تعريف وسائط الدالة كأنماط على النحو التالي:

دالة حساب مساحة الدائرة ( النقطة ، نصف القطر ) = π × مربع نصف القطر | مساحة المربع (النقطة، المسافة ) = مربع المسافة | مساحة المثلث ( نقطة ) = مربع نقطة ( انظر أعلاه)

إن ما يسمى بـ "الصيغة الشرطية" لتعريف الدالة، حيث يتم تعريف الوسائط كأنماط، ليس سوى اختصار نحوي لتعبير الحالة:

شكل المساحة الممتعة = حالة شكل الدائرة ( _, r ) => Math.pi * مربع r | مربع (_, s ) = > مربع s | مثلث p = > heron p

fun center ( Circle ( c , _)) = c | center ( Square (( x , y ), s )) = ( x + s / 2.0 , y + s / 2.0 )

دالة f ( دائرة (( x , y ), r )) = x + y | f ( دائرة _) = 1.0 | f _ = 0.0

val hasCorners = fn ( Circle _) => false | _ => true

يمكن للدوال أن تستهلك الدوال كوسائط:

دالة الخريطة f ( x , y ) = ( f x , f y )

يمكن للدوال أن تُنتج دوالًا أخرى كقيم مُعادة:

دالة ثابتة k = ( fn _ => k )

يمكن للدوال أيضًا أن تستهلك وتنتج الدوال:

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

تُعد الدالة الموجودة في المكتبةList.map الأساسية واحدة من أكثر الدوال عالية الرتبة استخدامًا في لغة Standard ML:

دالة map _ [] = [] | map f ( x :: xs ) = f x :: map f xs

تنفيذ أكثر كفاءة باستخدام الاستدعاء الذاتي الذيل List.foldl:

دالة map f = List . rev o List . foldl ( fn ( x , acc ) => f x :: acc ) []

تُثار الاستثناءات باستخدام الكلمة المفتاحية raiseويتم التعامل معها باستخدام handleبنية مطابقة الأنماط. يمكن لنظام الاستثناءات تنفيذ الخروج غير المحلي ؛ هذه التقنية المُحسِّنة مناسبة لوظائف مثل ما يلي.

استثناء محلي Zero ؛ val p = fn ( 0 , _) => raise Zero | ( a , b ) => a * b in fun prod xs = List . foldl p 1 xs handle Zero => 0 end

عند حدوث استثناء، يخرج التحكم من الدالة تمامًا. لنفترض البديل: ستُعاد القيمة 0، ثم تُضرب في العدد الصحيح التالي في القائمة، ثم تُعاد القيمة الناتجة (وهي حتمًا 0)، وهكذا. يسمح حدوث الاستثناء بتجاوز سلسلة الإطارات بأكملها وتجنب العمليات الحسابية المرتبطة بها. لاحظ استخدام الشرطة السفلية (_ ) كنمط بدل.exceptionZeroList.foldl_

يمكن الحصول على نفس التحسين باستخدام استدعاء الذيل .

دالة محلية p a ( 0 :: _) = 0 | p a ( x :: xs ) = p ( a * x ) xs | p a [] = a in val prod = p 1 end

يُتيح نظام الوحدات المتقدم في لغة Standard ML تقسيم البرامج إلى هياكل مُنظمة هرميًا ذات تعريفات منطقية للأنواع والقيم. لا توفر الوحدات التحكم في مساحة الأسماء فحسب ، بل توفر أيضًا التجريد، بمعنى أنها تسمح بتعريف أنواع البيانات المجردة . يتألف نظام الوحدات من ثلاثة عناصر نحوية رئيسية: التوقيعات، والهياكل، والدوال.

توقيع QUEUE = sig نوع 'a queue استثناء QueueError ؛ قيمة فارغة : 'a queue قيمة فارغة : 'a queue -> منطقي قيمة مفردة : 'a -> 'a queue قيمة من قائمة : 'a قائمة -> 'a queue قيمة إدراج : 'a * 'a queue -> 'a queue قيمة معاينة : 'a queue -> 'a قيمة إزالة : 'a queue -> 'a * 'a queue نهاية

structure TwoListQueue :> QUEUE = struct type 'a queue = 'a list * 'a listاستثناء QueueError ؛val empty = ([], [])دالة isEmpty ([], []) = صحيح | isEmpty _ = خطأدالة أحادية a = ([], [ a ])دالة fromList a = ([], a )دالة إدراج ( أ ، ([]، [])) = عنصر مفرد أ | إدراج ( أ ، ( إدراج ، إخراج )) = ( أ :: إدراج ، إخراج )دالة peek (_, []) = raise QueueError | peek ( ins , outs ) = List . hd outsدالة remove (_, []) = raise QueueError | remove ( ins , [ a ] ) = ( a , ([], List.revins ) ) | remove ( ins , a :: outs ) = ( a , ( ins , outs ) ) end

val q : string TwoListQueue . queue = TwoListQueue . empty val q' = TwoListQueue . insert ( Real . toString Math . pi , q )

(* نقلاً عن أوكازاكي، المؤتمر الدولي لعلم النفس الوظيفي، 2000 *) الدالة BFS ( Q : QUEUE ) = بنية البيانات 'a tree = E | T من 'a * 'a tree * 'a treeدالة محلية bfsQ q = إذا كانت Q فارغة ، فإن q فارغة ، وإلا ابحث ( Q.remove q ) وابحث ( E , q ) = bfsQ q | ابحث ( T ( x , l , r ) , q ) = x :: bfsQ ( insert ( insert q l ) r ) وابحث عن q a = Q.insert ( a , q ) في دالة bfs t = bfsQ ( Q.singleton t ) نهاية نهاية​​​​بنية QueueBFS = BFS ( TwoListQueue )

فيما يلي برنامج "مرحباً بالعالم!" :

اطبع "مرحباً بالعالم! \n " ;

$ mlton hello.sml $ ./hello مرحباً بالعالم!

لاحظ مدى سهولة تعريف ومعالجة لغة تعبيرية صغيرة:

استثناء TyErr ؛نوع البيانات ty = IntTy | BoolTyدالة unify ( IntTy , IntTy ) = IntTy | unify ( BoolTy , BoolTy ) = BoolTy | unify (_, _) = raise TyErrنوع البيانات exp = صحيح | خطأ | عدد صحيح من عدد صحيح | ليس من exp | جمع exp * exp | شرط من exp * exp * expدالة 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 )دالة 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

أمثلة على استخدام التعبيرات المكتوبة بشكل صحيح والتعبيرات المكتوبة بشكل خاطئ:

val SOME ( Int 3 ) = run ( Add ( Int 1 , Int 2 )) (* صحيح النوع *) val NONE = run ( If ( Not ( Int 1 ), True , False )) (* غير صحيح النوع *)

توفر هذه IntInfالوحدة عمليات حسابية للأعداد الصحيحة بدقة اختيارية. علاوة على ذلك، يمكن استخدام القيم العددية كأعداد صحيحة بدقة اختيارية دون الحاجة إلى أي تدخل من المبرمج.

البرنامج التالي ينفذ دالة مضروبية ذات دقة عشوائية:

حقيقة ممتعة n : IntInf . int = إذا كان n = 0 فإن 1 وإلا n * حقيقة ( n - 1 );fun printLine str = TextIO.output ( TextIO.stdOut , str ^ " \ n " ) ;​​val () = printLine ( IntInf.toString ( fact 120 ) ) ;

$ mlton fact.sml $ ./fact 6689502913449127057588118054090372586752746333138029810295671352301 6335572449629893668741652719849813081576378932140905525344085894081 21859898481114389650005964960521256960000000000000000000000000000

تُستخدم الدوال المُطبّقة جزئيًا في العديد من التطبيقات، مثل التخلص من التعليمات البرمجية المُكررة. على سبيل المثال، قد تتطلب وحدة برمجية دوالًا من نوع معين ، ولكن من الأنسب كتابة دوال من نوع آخر حيث توجد علاقة ثابتة بين كائنات من النوع الأول والثاني . يمكن لدالة من النوع الأول استخراج هذه العلاقة المشتركة. هذا مثال على نمط المُهايئ .a->ba*c->bacc->(a*c->b)->a->b

في هذا المثال، يتم حساب المشتقة العددية لدالة معينة عند النقطة :fundfx

- دالة d delta f x = ( f ( x + delta ) - f ( x - delta )) / ( 2.0 * delta ) قيمة d = دالة : حقيقي -> ( حقيقي -> حقيقي ) -> حقيقي -> حقيقي

يشير نوع الدالة إلى أنها تُسقط قيمة عددية عشرية على دالة من النوع المحدد . يسمح لنا هذا بتطبيق الوسائط جزئيًا، وهو ما يُعرف بالتطبيق الجزئي . في هذه الحالة، يمكن تخصيص الدالة بتطبيق الوسيط المحدد جزئيًا عليها . يُعد الجذر التكعيبي لقيمة إبسيلون خيارًا مناسبًا عند استخدام هذه الخوارزمية .fund(real->real)->real->realddeltadelta

- val d' = d 1E~8 ; val d' = fn : ( real -> real ) -> real -> real

يشير النوع المُستنتج إلى أن d'الدالة تتوقع دالة يكون نوعها هو وسيطها الأول. يمكننا حساب تقريب لمشتقةreal->real${\displaystyle f(x)=x^{3}-x-1}$في${\displaystyle x=3}$الإجابة الصحيحة هي${\displaystyle f'(3)=27-1=26}$.

- d' ( fn x => x * x * x - x - 1.0 ) 3.0 ; val it = 25.9999996644 : real

تم توحيد مكتبة Basis ^{[ 8 ]} وتأتي مع معظم التطبيقات. وهي توفر وحدات للأشجار والمصفوفات وهياكل البيانات الأخرى، بالإضافة إلى واجهات الإدخال/الإخراج وواجهات النظام.

بالنسبة للحوسبة العددية ، توجد وحدة Matrix (لكنها معطلة حاليًا)، https://www.cs.cmu.edu/afs/cs/project/pscico/pscico/src/matrix/README.html .

فيما يخص الرسومات، تُعدّ cairo-sml واجهة مفتوحة المصدر لمكتبة Cairo للرسومات. أما في مجال التعلّم الآلي، فتوجد مكتبة خاصة بالنماذج الرسومية.