OCaml
उच्च आदेश कार्य

वाक्य - विन्यास

• val (|>) : 'a -> ('a -> 'b) -> 'b
• val (@@) : ('a -> 'b) -> 'a -> 'b

सामान्य एल्गोरिदम

उच्च-क्रम वाले कार्यों का उपयोग जेनेरिक एल्गोरिदम को लागू करने के लिए किया जा सकता है, जो उपयोगकर्ता को अंतिम विवरण प्रदान करने की जिम्मेदारी देता है। उदाहरण के लिए List.sort एक तुलना फ़ंक्शन की अपेक्षा करता है, जो सॉर्टिंग के विभिन्न तरीकों को लागू करने की अनुमति देता है। यहाँ हम केस-असंवेदनशील स्ट्रिंग्स को लागू करते हैं:

let string_case_insensitive_sort lst =
  let case_insensitive_compare a b =
    String.compare (String.lowercase a) (String.lowercase b)
  in
  List.sort case_insensitive_compare lst

मानक पुस्तकालय में उच्च-क्रम के कार्यों की एक समृद्ध सूची है, विशेष रूप से सूची मॉड्यूल में, उदाहरण के लिए List.fold_left और List.sort देखें। अधिक उन्नत उदाहरण तीसरे पक्ष के पुस्तकालयों में पाए जा सकते हैं। एक अच्छा उदाहरण ओम्माल-जीएसएल में कार्यान्वित सिम्युलेटेड एनीलिंग है । सिम्युलेटेड एनेलिंग एक सामान्य अनुकूलन प्रक्रिया है जो समस्या के राज्यों और एक त्रुटि फ़ंक्शन (जिसे यहां ऊर्जा फ़ंक्शन कहा जाता है) के सेट का पता लगाने के लिए उपयोग किए जाने वाले फ़ंक्शन द्वारा पैरामीट्राइज़ किया जाता है।

C ++ से परिचित उपयोगकर्ता इसकी तुलना रणनीति पैटर्न से कर सकते हैं।

अपवाद बढ़ाए जाने पर भी सिस्टम संसाधनों का निपटान करें

उच्च-क्रम के कार्यों का उपयोग यह सुनिश्चित करने के लिए किया जा सकता है कि सिस्टम संसाधनों का निपटान किया जाता है, तब भी जब कोई उपचार अपवाद उठाता है। द्वारा इस्तेमाल किया पद्धति with_output_file चिंताओं में से एक साफ जुदाई की अनुमति देता है: उच्च क्रम with_output_file कार्यों सिस्टम संसाधन फ़ाइल हेरफेर करने के लिए बाध्य का प्रबंधन करते हुए उपचार का ख्याल रखता है f केवल उत्पादन चैनल खपत करता है।

let with_output_file path f =
  let c = open_out path in
  try
    let answer = f c in
    (close_out c; answer)
  with exn -> (close_out c; raise exn)

एक फ़ाइल में एक स्ट्रिंग लिखने वाले फ़ंक्शन को लागू करने के लिए इस उच्च-क्रम फ़ंक्शन का उपयोग करें:

let save_string path s =
  (with_output_file path) (fun c -> output_string c s)

fun c -> output_string cs से अधिक उन्नत कार्यों का उपयोग करके अधिक जटिल मूल्यों को सहेजना संभव है। उदाहरण के लिए देखें मानक पुस्तकालय या मार्टिन जाम्बोन द्वारा योजोन पुस्तकालय में मार्शल मॉड्यूल।

रचना संचालक

दो उपयोगी उच्च-क्रम फ़ंक्शन बाइनरी एप्लिकेशन ( @@ ) और रिवर्स-एप्लिकेशन या "पाइप" ( |> ) ऑपरेटर हैं। हालांकि 4.01 के बाद से वे आदिम के रूप में उपलब्ध हैं, यह अभी भी उन्हें यहाँ परिभाषित करने के लिए शिक्षाप्रद हो सकता है:

let (|>) x f = f x
let (@@) f x = f x

के वर्ग को बढ़ाने की समस्या पर विचार करें 3. अभिकलन व्यक्त करने का एक तरीका यह है:

(* 1 -- Using parentheses *)
succ (square 3)
(* - : int = 10 *)

(* where `square` is defined as: *)
let square x = x * x

ध्यान दें कि हम बस succ square 3 को नहीं कर सकते क्योंकि ( बाएं- succ square 3 कारण) जो व्यर्थ (succ square) 3 कम हो जाएगा। एप्लिकेशन ( @@ ) का उपयोग करके हम इसे बिना कोष्ठकों के व्यक्त कर सकते हैं:

(* 2 -- Using the application operator *)
succ @@ square 3
(* - : int = 10 *)

ध्यान दें कि अंतिम ऑपरेशन कैसे किया जाता है (अर्थात् succ ) पहले अभिव्यक्ति में होता है? रिवर्स-एप्लिकेशन ऑपरेटर ( |> ) हमें इसकी अनुमति देता है, ठीक है, इसे उल्टा करें:

(* 3 -- Using the reverse-application operator *)
3 |> square |> succ
(* - : int = 10 *)

संख्या 3 को अब square माध्यम से "पाइप" किया जाता है और फिर succ , जिसके परिणामस्वरूप square को लागू करने के लिए जिसके परिणामस्वरूप succ पर लागू किया जाता है।