मैं एमएल के लिए बिल्कुल नया हूं और मैं पैटर्न मिलान के लिए वाक्यविन्यास को समझने की कोशिश कर रहा हूं। क्या कोई मुझे कंपाइलर त्रुटि को समझने में मदद कर सकता है, और पैटर्न के लिए सही सिंटैक्स AssignStm से मेल खाता है, जबकि इसके दूसरे तर्क को वेरिएबल e से बांधता है?

हो सकता है कि मैं जो करने की कोशिश कर रहा हूं वह समर्थित नहीं है? मेरे पास निम्नानुसार परिभाषित एक एडीटी है।

type id = string

datatype binop = Plus | Minus | Times | Div

datatype stm = CompoundStm of stm * stm
             | AssignStm of id * exp
             | PrintStm of exp list

     and exp = IdExp of id
             | NumExp of int
             | OpExp of exp * binop * exp
             | EseqExp of stm * exp

और मैं एक फ़ंक्शन को लागू करने का प्रयास कर रहा हूं जो किसी दिए गए कथन में print पर कॉल की संख्या की गणना करता है।

संकलक शिकायत करता है

/Users/jimka/Repos/mciml/fig4.1.sml:15.60 Error: unbound variable or constructor: e

यहाँ मेरा कोड है:

fun maxints(a,b) =
    if a > b then a else b

fun maxargs PrintStm nil = 0 
  | maxargs PrintStm h::t = 1 + (maxargs printStm t )
  | maxargs CompoundStm(a,b) =  maxints(maxargs a, maxargs b)
  | maxargs AssignStm(_,e: exp) = maxargs e        (* the error is on this line *)
  | maxargs IdExp = 0 
  | maxargs NumExp = 0
  | maxargs OpExp(e1,_,e2) = maxints(maxargs e1, maxargs e2)
  | maxargs EseqExp(s,e) = maxints(maxargs s, maxargs e)

त्रुटि को ट्रिगर करने वाला वास्तविक कोड निम्न है:

val prog =
    CompoundStm(AssignStm("a",OpExp(NumExp 5, Plus, NumExp e)),
                CompoundStm(AssignStm("b",
                                      EseqExp(PrintStm[IdExp"a", OpExp(IdExp"a", Minus,
                                                                       NumExp 1)],
                                              OpExp(NumExp 10, Times IdExp"a"))),
                            PrintStm[IdExp "b"]))


maxargs prog

Molbdnilo ने निम्नलिखित सुझाव दिया। लेकिन मुझे वही त्रुटि मिलती है।

fun maxargs( PrintStm nil) = 0 
  | maxargs( PrintStm (h::t)) = 1 + maxints(maxargs(h), maxargs( PrintStm( t )))
  | maxargs( CompoundStm (a,b)) =  maxints(maxargs( a), maxargs( b))
  | maxargs( AssignStm (_,e)) = maxargs( e)
  | maxargs( IdExp (_)) = 0 
  | maxargs( NumExp (_)) = 0
  | maxargs( OpExp (e1,_,e2)) = maxints(maxargs e1, maxargs e2)
  | maxargs( EseqExp (s,e)) = maxints( maxargs(s),  maxargs(e))
0
Jim Newton 29 पद 2020, 17:30

1 उत्तर

सबसे बढ़िया उत्तर

तत्काल समस्या एक पैटर्न-मिलान समस्या नहीं है, लेकिन उस prog में NumExp e है, जबकि आपने e को कहीं भी परिभाषित नहीं किया है।

आपको यह भी समस्या है कि आप maxargs को stm या exp लेने की कोशिश कर रहे हैं, और आप ऐसा नहीं कर सकते।

भी,

fun maxargs PrintStm nil = 0 

एक फ़ंक्शन को परिभाषित करेगा जो दो तर्क लेता है; PrintStm और nil

आपको पैटर्न के चारों ओर कोष्ठक की आवश्यकता है, और आपको दो परस्पर पुनरावर्ती कार्यों की आवश्यकता है:

fun maxargs_stm (PrintStm nil) = 0 
  | maxargs_stm (PrintStm (h::t)) = 1 + (maxargs_stm (PrintStm t))
  | maxargs_stm (CompoundStm(a,b)) =  maxints(maxargs_stm a, maxargs_stm b)
  | maxargs_stm (AssignStm(_,e: exp)) = maxargs_exp e
and maxargs_exp (IdExp _) = 0 
  | maxargs_exp (NumExp _) = 0
  | maxargs_exp (OpExp(e1,_,e2)) = maxints(maxargs_exp e1, maxargs_exp e2)
  | maxargs_exp (EseqExp(s,e)) = maxints(maxargs_stm s, maxargs_exp e);
1
molbdnilo 29 पद 2020, 20:59
हम्म। अफसोस की बात है कि यह मदद नहीं करता है। मुझे उस परिवर्तन के बाद वही त्रुटि मिलती है।
 – 
Jim Newton
29 पद 2020, 18:55
मैं आपके सुझावों को दर्शाने के लिए मूल पोस्ट अपडेट करूंगा।
 – 
Jim Newton
29 पद 2020, 19:02
आह, prog में NumExp e शामिल हैं। अब मैं देख रहा हूँ, मैं पूरी तरह से पैटर्न मैच में e को देख रहा था। धन्यवाद।
 – 
Jim Newton
30 पद 2020, 13:34
अगला कि मैं maxargs को stm या exp स्वीकार करने के लिए परिभाषित नहीं कर सकता, स्पष्ट नहीं था। मुझे लगा कि यह भाषा की एक विशेषता मात्र है। हालांकि, क्या मैं किसी तरह entity को stm | exp के रूप में परिभाषित कर सकता हूं? इस प्रकार maxargs फिर entity से int को मैप करेगा? अर्थात। क्या | केवल कंस्ट्रक्टर्स के साथ काम करता है या यह टाइप नामों के साथ भी काम करता है?
 – 
Jim Newton
30 पद 2020, 13:52
यदि आप इस तरह एक संघ प्रकार चाहते हैं, तो आप प्रत्येक विकल्प के लिए एक नया डेटाटाइप और एक कन्स्ट्रक्टर परिभाषित कर सकते हैं, हालांकि मेरी राय है कि दो पारस्परिक रूप से पुनरावर्ती कार्य (जैसा कि molbdnilo प्रस्तुत करता है) बेहतर समाधान है।
 – 
kopecs
1 जिंदा 2021, 00:29