उच्च आदेश प्रकार निर्माणकर्ता और OCaml

Question

में functors निम्नलिखित बहुरूपी कार्यों

let id x = x;; 
let compose f g x = f (g x);; 
let rec fix f = f (fix f);;  (*laziness aside*) 

प्रकार/प्रकार कंस्ट्रक्टर्स या मॉड्यूल/functors के लिए लिखा जा सकता है? मैंने

type 'x id = Id of 'x;; 
type 'f 'g 'x compose = Compose of ('f ('g 'x));; 
type 'f fix = Fix of ('f (Fix 'f));; 

प्रकारों के लिए प्रयास किया लेकिन यह काम नहीं करता है।

data Id x = Id x 
data Compose f g x = Compose (f (g x)) 
data Fix f = Fix (f (Fix f)) 

-- examples: 
l = Compose [Just 'a'] :: Compose [] Maybe Char 

type Natural = Fix Maybe -- natural numbers are fixpoint of Maybe 
n = Fix (Just (Fix (Just (Fix Nothing)))) :: Natural -- n is 2 

-- up to isomorphism composition of identity and f is f: 
iso :: Compose Id f x -> f x 
iso (Compose (Id a)) = a 

Answer 1

हास्केल उच्च तरह का चर टाइप अनुमति देता है:

यहाँ प्रकारों के लिए एक हास्केल संस्करण है। कैमल समेत एमएल बोलियां, केवल "*" प्रकार के प्रकार चर की अनुमति देती हैं। , सादे अंग्रेजी में अनुवाद किया

• हास्केल में, एक प्रकार चर gMaybe या IO या सूचियों की तरह एक "प्रकार निर्माता" के अनुरूप कर सकते हैं। तो आपके हास्केल उदाहरण में g x ठीक होगा (शब्दकोष: "अच्छी तरह से दयालु") उदाहरण के लिए gMaybe और xInteger है।

• एमएल में, एक प्रकार चर 'goption या list की तरह एक प्रकार निर्माता के लिए कभी नहीं, int या string की तरह एक "जमीन प्रकार" के लिए एक ही अनुरूप कर सकते हैं। इसलिए कभी किसी अन्य प्रकार के प्रकार को लागू करने का प्रयास करने के लिए सही नहीं है।

जहां तक ​​मुझे पता है, एमएल में इस सीमा के लिए कोई गहरा कारण नहीं है। सबसे अधिक संभावना स्पष्टीकरण ऐतिहासिक आकस्मिकता है। जब मिलनर मूल रूप से बहुरूपता के बारे में अपने विचारों के साथ आया, तो उन्होंने बहुत ही सरल प्रकार के चर के साथ काम किया जो केवल प्रकार के मोनोटाइप के लिए खड़े थे। हास्केल के प्रारंभिक संस्करणों ने वही किया, और फिर कुछ बिंदु पर मार्क जोन्स ने पाया कि प्रकार के प्रकारों का प्रकार वास्तव में काफी आसान है। हास्केल को उच्च प्रकार के प्रकार चर की अनुमति देने के लिए जल्दी से संशोधित किया गया था, लेकिन एमएल ने कभी पकड़ा नहीं है।

आईएनआरआईए के लोगों ने एमएल में कई अन्य बदलाव किए हैं, और मुझे आश्चर्य है कि उन्होंने इसे कभी नहीं बनाया है। जब मैं एमएल में प्रोग्रामिंग कर रहा हूं, तो मुझे उच्च-प्रकार के प्रकार चर होने का आनंद हो सकता है। लेकिन वे वहां नहीं हैं, और functors का उपयोग करके आप जिन उदाहरणों के बारे में बात कर रहे हैं, उन्हें एन्कोड करने का कोई तरीका नहीं है।

Answer 2

आप उच्च क्रम प्रकारों के स्थान पर प्रकार के स्थान पर मॉड्यूल का उपयोग करके, और मल्टीक्टरों (उच्च-आदेश मॉड्यूल) का उपयोग करके ओकैमल में कुछ ऐसा कर सकते हैं। लेकिन यह बहुत अधिक दिखता है और इसमें टाइप-इनफरेंस क्षमता नहीं है, इसलिए आपको मैन्युअल रूप से बहुत सारी चीज़ें निर्दिष्ट करनी होंगी।

module type Type = sig 
    type t 
end 

module Char = struct 
    type t = char 
end 

module List (X:Type) = struct 
    type t = X.t list 
end 

module Maybe (X:Type) = struct 
    type t = X.t option 
end 

(* In the following, I decided to omit the redundant 
    single constructors "Id of ...", "Compose of ...", since 
    they don't help in OCaml since we can't use inference *) 

module Id (X:Type) = X 

module Compose 
    (F:functor(Z:Type)->Type) 
    (G:functor(Y:Type)->Type) 
    (X:Type) = F(G(X)) 

let l : Compose(List)(Maybe)(Char).t = [Some 'a'] 

module Example2 (F:functor(Y:Type)->Type) (X:Type) = struct 
    (* unlike types, "free" module variables are not allowed, 
    so we have to put it inside another functor in order 
    to scope F and X *) 
    let iso (a:Compose(Id)(F)(X).t) : F(X).t = a 
end 

Answer 3

अच्छा ... मैं उच्च-आदेश-प्रकारों और नस्केल प्रोग्रामिंग का विशेषज्ञ नहीं हूं। लेकिन यह एफ # (जो OCaml है) के लिए ठीक हो रहा है, तो आप इन के साथ काम कर सकता था:

type 'x id = Id of 'x;; 
type 'f fix = Fix of ('f fix -> 'f);; 
type ('f,'g,'x) compose = Compose of ('f ->'g -> 'x);; 

पिछले एक मैं के रूप में मैं कुछ भी बेहतर के साथ नहीं आया था टपल को लपेटा ...

Answer 4

तुम कर सकते हो, लेकिन आप एक चाल का एक सा बनाने की जरूरत है:

newtype Fix f = In{out:: f (Fix f)} 

आप Cata बाद में परिभाषित कर सकते हैं:

Cata :: (Functor f) => (f a -> a) -> Fix f -> a 
Cata f = f.(fmap (cata f)).out 

बस इतना ही functors, के लिए एक सामान्य catamorphism निर्धारित करेंगी कि आप अपनी खुद की सामग्री बनाने के लिए उपयोग कर सकते हैं। उदाहरण:

data ListFix a b = Nil | Cons a b 
data List a = Fix (ListFix a) 
instance functor (ListFix a) where 
fmap f Nil = Nil 
fmap f (Cons a lst) = Cons a (f lst)