उच्च ऑर्डर फ़ंक्शन का प्रकार

Question

यदि मैं उच्च आदेश फ़ंक्शन के लिए (मुझे लगता है) सही प्रकार निर्दिष्ट करता है तो ओकैमल कंपाइलर दूसरा उस फ़ंक्शन का उपयोग अस्वीकार करता है।

कोड

let foo():string = 
    let f: ('a -> string) -> 'a -> string = fun g v -> g v 
    in let h = string_of_int 
    in let i = string_of_float 
    in let x = f h 23 
    in let y = f i 23.0 
    in x^y 

निम्न त्रुटि संदेश

File "test.ml", line 6, characters 14-15: 
Error: This expression has type float -> string 
     but an expression was expected of type int -> string

तो f का सर्वप्रथम प्रयोग int -> string करने के लिए अपने पहले पैरामीटर के प्रकार को ठीक करने लगता है की ओर जाता है। मैं इसे समझ सकता था। लेकिन मुझे यह नहीं मिला कि f पर प्रकार प्रतिबंध को छोड़कर समस्या ठीक हो जाती है।

let foo():string = 
    let f g v = g v 
    in let h = string_of_int 
    in let i = string_of_float 
    in let x = f h 23 
    in let y = f i 23.0 
    in x^y

और आगे बढ़ f वैश्विक विस्तार के लिए समस्या है, भी ठीक करता है:

let f: ('a -> string) -> 'a -> string = fun g v -> g v 

let foo():string = 
    let h = string_of_int 
    in let i = string_of_float 
    in let x = f h 23 
    in let y = f i 23.0 
    in x^y

क्यों कि पहला उदाहरण बाद में लोगों को करना है, जबकि संकलन नहीं है कि यह कर रहा है?

Answer 1

मुझे एक सरल उदाहरण है कि मुद्दे को दर्शाता है का उपयोग करते हैं।

# let cons0 (x : 'a) (y : 'a list) = x :: y;; 
val cons0 : 'a -> 'a list -> 'a list = <fun> 
# let cons1 (x : 'a) (y : 'a list) = x :: y in cons1 1 [];; 
- : int list = [1] 
# let cons2 (x : 'a) (y : 'a list) = x :: y in (cons2 1 [], cons2 true []);; 
This expression has type bool but is here used with type int 
# let cons3 x y = x :: y in (cons3 1 [], cons3 true []);; 
- : int list * bool list = ([1], [true]) 

cons0 एक बहुरूपी समारोह परिभाषा, वैश्विक क्षेत्र में परिभाषित किया गया है। यह :: ऑपरेटर के लिए बस एक छोटा सा रैपर है। अनजाने में, परिभाषा काम करता है। cons1 लगभग cons0 जैसा ही है, सिवाय इसके कि इसका दायरा in शरीर में अभिव्यक्ति तक सीमित है। गुंजाइश का परिवर्तन निर्दोष दिखता है, और निश्चित रूप से पर्याप्त है, यह टाइप चेक करता है। cons3 फिर से एक ही फ़ंक्शन है, बिना किसी प्रकार की एनोटेशन के, और हम in शरीर में इसे polymorphically उपयोग कर सकते हैं।

तो cons2 के साथ क्या गलत है? समस्या 'a का दायरा है: यह संपूर्ण अपूर्ण वाक्यांश है।मुहावरा है कि cons2 को परिभाषित करता है के शब्दों

for some type 'a, (let cons2 (x : 'a) (y : 'a list) = ... in ...) 

'a के बाद से साथ intbool (करने के लिए cons3 1 [] कारण) और के साथ (cons3 true [] के कारण, 'a का कोई संभव इन्स्टेन्शियशन है संगत होना चाहिए है। इसलिए वाक्यांश बीमार है आपके द्वारा लिखा गया।

आप अपने सामान्य प्रकार निष्कर्ष एल्गोरिथ्म के मामले में एमएल टाइपिंग के बारे में सोचना चाहते हैं, तो प्रत्येक उपयोगकर्ता की स्पष्ट अनुमति चर एकीकरण एल्गोरिथ्म में कमी का एक सेट प्रस्तुत करता है। यहाँ की कमी 'a = "type of the parameter x" और ' = "type of the parameter y" कर रहे हैं। लेकिन शंघाई सहयोग संगठन 'a का पे पूरे वाक्यांश है, यह किसी भी आंतरिक दायरे में सामान्यीकृत नहीं है। तो int और bool दोनों गैर-सामान्यीकृत 'a के लिए एकीकृत होते हैं।

हाल के संस्करण ओकैमल स्कॉप्ड प्रकार चर (जैसे Niki Yoshiuchi's answer) प्रस्तुत करते हैं।

let module M = struct 
    let cons2 (x : 'a) (y : 'a list) = x :: y 
    end in 
(M.cons2 1 [], M.cons2 true []);; 

(स्टैंडर्ड MLers ध्यान दें::। यह एक ऐसी जगह है जहां OCaml और एसएमएल अलग है)

Answer 2

यह एक वास्तविक सिर-स्क्रैचर है और अगर यह एक कंपाइलर बग है तो मुझे आश्चर्य नहीं होगा। जिसके अनुसार, आप स्पष्ट रूप से प्रकार नामकरण से आप क्या चाहते हैं कर सकते हैं: http://caml.inria.fr/pub/docs/manual-ocaml/manual021.html#htoc108

संपादित करें::

यह भी काम करता है:

let f g v:string = g v in 

है जो

let f (type t) (g: t->string) (v: t) = g v in 

पुस्तिका से जिस प्रकार का हस्ताक्षर आप ढूंढ रहे हैं: ('a -> string) -> 'a -> string

अजीब बात यह है कि जब आप तर्कों के प्रकार को एनोटेट करते हैं तो यह काम नहीं करता है।

संपादित करें:

बहुरूपी प्रकार टिप्पणियों को एक विशेष सिंटेक्स है:

let f: 'a. ('a -> string)-> 'a -> string = fun g v -> g v in 

और प्रकार बहुरूपी होना आवश्यक है: http://caml.inria.fr/pub/docs/manual-ocaml/manual021.html#toc79

Answer 3

एक संदर्भ बिंदु के रूप में एक ही प्रभाव पिछले संस्करणों में एक स्थानीय मॉड्यूल (≥2.0) के साथ प्राप्त किया जा सकता था , समकक्ष एफ #

let foo():string = 
    let f: ('a -> string) -> 'a -> string = fun g v -> g v 
    let h = string 
    let i = string 
    let x = f h 23 
    let y = f i 23.0 
    x^y 

संकलित करता है।