हास्केल फ़ंक्शन जो एक प्रकार और मान लेता है और जांच करता है कि मान

Question

है, तो मैं हास्केल में एक साधारण योजना दुभाषिया बनाने की कोशिश कर रहा हूं। इस के हिस्से के रूप में, मैं कुछ आदिम ऑपरेटरों को लागू कर रहा हूं जैसे संख्या ?, स्ट्रिंग? आदि

मैं इस तरह कोड है:

isNumber :: [LispVal] -> LispVal 
isNumber ([Number n]) = Bool True 
isNumber   _ = Bool False 

isString :: [LispVal] -> LispVal 
isString ([String n]) = Bool True 
isString   _ = Bool False 

और क्या मैं करना चाहते हैं, जैसे

isType :: ?? -> [LispVal] -> LispVal 
isType (typeName [typeName n]) = Bool True 
isType      _ = Bool False 

दूसरे शब्दों में कुछ है मैं द्वारा ISNUMBER के बराबर बनाना चाहते हैं "आईट टाइप नंबर" कह रहा है। क्या यह किसी भी तरह से संभव है? मैं Google में कुछ भी ढूंढने के लिए संघर्ष कर रहा हूं, शायद क्योंकि मुझे नहीं पता कि स्थिति को क्या कहना है।

Answer 1

मैं यह सोचते कर रहा हूँ आप इस तरह एक प्रकार कुछ है:

data LispVal = String String | Number Double -- &c.... 

... और आप एक समारोह है कि परीक्षण है कि क्या एक LispVal मूल्य एक विशेष निर्माता है चाहते हैं (String, Number, & सी।) कुछ तर्क के आधार पर।

दुर्भाग्य से ऐसा करने के लिए वास्तव में एक सरल, सामान्य तरीका नहीं है।

आप स्ट्रिंग तुलना का सहारा सकता है:

getTypeName :: LispVal -> String 
getTypeName (String _) = "String" 
getTypeName (Number _) = "Number" 

isType :: String -> [LispVal] -> LispVal 
isType name [val] = Bool (name == getTypeName val) 
isType _ _ = Bool False 

या आप दो LispVal रों के प्रकार की तुलना कर सकते:

sameType :: LispVal -> LispVal -> LispVal 
sameType (String _) (String _) = Bool True 
sameType (Number _) (Number _) = Bool True 
sameType _ _ = Bool False 

... और फिर isType के लिए के साथ तुलना करने के लिए एक डमी मूल्य बनाने ।

तुम भी एक "प्रकार" मूल्य बनाने के लिए और LispVal रों पर प्रतिबिंब का एक तरह लागू कर सकता है, तो उन के आधार पर की तुलना करें:

data LispType = LispString | LispNumber | LispType 

getType :: LispVal -> LispVal 
getType (String _) = Type LispString 
getType (Number _) = Type LispNumber 
getType (Type _) = Type LispType 

isType :: LispVal -> [LispVal] -> LsipVal 
isType t [v] = isEqual t (getType v) 
isType _ _ = Bool False 

इन तरीकों में से एक पर कुछ भिन्नता शायद आपका सबसे अच्छा विकल्प है। हास्केल की अधिक उन्नत सुविधाओं के आधार पर अन्य तरीके भी हैं, लेकिन संभवतः वे परेशानी के लायक नहीं हैं जब तक कि व्याख्या की गई भाषा के प्रकार हास्केल के प्रकारों के साथ अधिक निकटता से बंधे न हों।