OCaml
कार्य

एक बंधन के साथ एक कार्य को परिभाषित करना

मान का उपयोग let हुए नाम दिए जा सकते हैं:

# let a = 1;;
val a : int = 1 

आप फ़ंक्शन को परिभाषित करने के लिए समान सिंटैक्स का उपयोग कर सकते हैं। बस तर्कों के लिए अतिरिक्त पैरामीटर प्रदान करें।

# let add arg1 arg2 = arg1 + arg2;;
val add : int -> int -> int = <fun> 

हम इसे इस तरह कह सकते हैं:

# add 1 2;;
- : int = 3 

हम मूल्यों को सीधे उस तरह से पारित कर सकते हैं, या हम नामों से बंधे मूल्यों को पारित कर सकते हैं:

# add a 2;;
- : int = 3 

किसी चीज़ को परिभाषित करने के बाद दुभाषिया हमें जो लाइन देता है, वह उसके प्रकार के हस्ताक्षर के साथ वस्तु का मूल्य है। जब हम यह करने के लिए बाध्य एक सरल मूल्य दे दी है a , इसके साथ वापस आ गया:

val a : int = 1

इसका मतलब है a एक है int , और इसके मूल्य है 1 ।

हमारे फ़ंक्शन का प्रकार हस्ताक्षर थोड़ा अधिक जटिल है:

val add : int -> int -> int = <fun> 

add का प्रकार हस्ताक्षर ints और तीरों का एक गुच्छा जैसा दिखता है। ऐसा इसलिए है क्योंकि एक फ़ंक्शन जो दो तर्क लेता है, वास्तव में एक फ़ंक्शन है जो सिर्फ एक तर्क लेता है, लेकिन एक और फ़ंक्शन देता है जो अगला तर्क लेता है। आप इसके बजाय इसे इस तरह पढ़ सकते हैं:

val add : int -> (int -> int) = <fun>

यह उपयोगी है जब हम मक्खी पर विभिन्न प्रकार के कार्य बनाना चाहते हैं। उदाहरण के लिए, एक फ़ंक्शन जो 5 से सब कुछ जोड़ता है:

# let add_five = add 5;;
val add_five : int -> int = <fun>
# add_five 5;;
- : int = 10
# add_five 10;;
- : int = 15 

फ़ंक्शन कीवर्ड का उपयोग करना

जब आप अपने फ़ंक्शन के मुख्य भाग को परिभाषित करते हैं तो function कीवर्ड में स्वचालित रूप से पैटर्न मिलान होता है। इसे नीचे देखें:

# let foo = function
0 -> "zero"
| 1 -> "one"
| 2 -> "couple"
| 3 -> "few"
| _ -> "many";;
val foo : int -> bytes = <fun>

# foo 0;;
- : bytes = "zero"

# foo 3;;
- : bytes = "few"                                                                         

# foo 10;;
- : bytes = "many"                                                                        

# let bar = function
"a" | "i" | "e" | "o" | "u" -> "vowel"
| _ -> "consonant";;
val bar : bytes -> bytes = <fun>                                                          

# bar "a";;
- : bytes = "vowel"

# bar "k";;
- : bytes = "consonant" 

अनाम कार्य

चूंकि फ़ंक्शन सामान्य मान हैं, इसलिए नाम के बिना फ़ंक्शन बनाने के लिए एक सुविधाजनक वाक्यविन्यास है:

List.map (fun x -> x * x) [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)

यह आसान है, क्योंकि हमें अन्यथा फ़ंक्शन को पहले नाम देना होगा ( चलो देखते हैं ) इसका उपयोग करने में सक्षम होने के लिए:

let square x = x * x
(* val square : int -> int = <fun> *)

List.map square [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)

पुनरावर्ती और पारस्परिक रूप से पुनरावर्ती कार्य

आप एक फ़ंक्शन को rec कीवर्ड के साथ पुनरावर्ती होने के लिए परिभाषित कर सकते हैं, इसलिए यह स्वयं कॉल कर सकता है।

# let rec fact n = match n with
    | 0 -> 1
    | n -> n * fact (n - 1);;

val fact : int -> int = <fun>

# fact 0;;
- : int = 1
# fact 4;;
- : int = 24

आप and कीवर्ड के साथ परस्पर पुनरावर्ती कार्यों को भी परिभाषित कर सकते हैं, इसलिए वे एक दूसरे को कॉल कर सकते हैं।

# let rec first x = match x with
    | 1 -> 1
    | x -> second (x mod 10)

  and second x = first (x + 1);;

val first : int -> int = <fun>
val second : int -> int = <fun>

# first 20;;
- : int = 1
# first 12345;;
- : int = 1

ध्यान दें कि दूसरे फ़ंक्शन में req कीवर्ड नहीं है।