एक नए प्रकार के डेटा कन्स्ट्रक्टर में फ़ंक्शन परिभाषा का उदाहरण

Question

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

type FuncDef = Int -> Int -> Int 

यह हर बार लंबी फ़ंक्शन परिभाषा लिखने से बचाता है।

उपयोग:

someFunc :: FuncDef -> Int 

बजाय

someFunc :: (Int -> Int -> Int) -> Int 

जो अधिक पठनीय और कम कोड के रूप में अच्छी तरह से है।

सरल बीजगणितीय डेटा प्रकार सीधे आगे और पैटर्न मिलान आदि करने में आसान हैं, उदाहरण के लिए

data AType = X | Y | Z Int 
matchType :: AType -> Bool 
matchType X = .. 
matchType Y = .. 
matchType (Z _) = .. 

जैसा कि मैंने हास्केल डेटा प्रकार में और अधिक लग रही है, मैंने पाया हम डेटा निर्माता में समारोह परिभाषा हो सकती है जब नए प्रकार को परिभाषित।

data MyType a b = X | Y (a -> b) 

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

matchMyType :: (MyType a b) -> Bool 
matchMyType X = .. 
matchMyType Y ?? = .. 

Answer 1

आप कई स्थितियों में इस तरह के पैटर्न का उपयोग कर सकते हैं। उदाहरण के लिए, यदि आप एक समारोह है कि विभिन्न तरीकों से तार बदल देती हैं, तो आप इस तरह एक डेटा प्रकार हो सकता है (यह एक उदाहरण मात्र है कि सिद्धांत को दर्शाता है है - इस तरह कोड लिखने नहीं है!):

data StringTransformation = 
    -- | Doesn't transform the string at all 
    NoTransformation | 
    -- | Takes the string and generates a suffix that should be appended 
    Append (String -> String) | 
    -- | Takes the string and generates a prefix that should be prepended 
    Prepend (String -> String) | 
    -- | Takes the string and transforms it arbitrarily to a new string 
    Map (String -> String) 

फिर, इसका उपयोग करने वाला एक प्रोग्राम इस तरह दिख सकता है:

-- | Returns 'True' if the name is male 
isMaleName :: String -> Bool 
isMaleName = ... 

-- | Adds a title to a name, for example "John Smith" -> "Mr. John Smith" 
addTitle :: StringTransformation 
addTitle = 
    PrependTransformation $ \ name -> 
    if isMaleName name 
    then "Mr. " 
    else "Mrs. " 

-- Applies a string transformation to a 'String'. 
transformString :: StringTransformation -> String -> String 
transformString NoTransformation str = str 
transformString (Append f) str  = str ++ f str 
transformString (Prepend f) str  = f str ++ str 
transformString (Map f) str   = f str 

Answer 2

data Thingy a b = A b 
       | B (a -> b) 

really :: Thingy a b -> a -> b 
really (A x) _ = x    -- x :: b 
really (B f) y = f y   -- f :: a -> b, y :: a, f y :: b 

C.A.McCann कहते हैं, वहाँ वास्तव में कार्यों के बारे में कुछ खास नहीं है।