recursion - counting a data type non-recursively -

मेरे पास डेटाटाइप है:

  डेटाटाइप int A = int * स्ट्रिंग का पत्ता | कहें कि मेरे पास टेस्ट है: इंट ए, तो मैं परीक्षा में पत्ते और चड्डी गिनती करना चाहता हूं और उन्हें एक जोड़े के रूप में वापस करना चाहता हूं: (# लीफ़्स, # चड्डी)। हालांकि मैं पुनरावर्तन का उपयोग नहीं करना चाहता।  
 यह मेरा प्रयास था:  
  मजेदार गणना (परीक्षण: int A): int * int = case trunk (a , एल) = & gt; वाल l1 = List.filter (fn trunk (a ', l') = & gt; सही | _ = & gt; गलत) l val l2 = List.filter (fn leaf (a ', s) = & gt; true | _ = & Gt; झूठे) एल (सूची.लांबी (एल 2), सूची.लाइन (l1) + 1) अंत | पत्ती (ए, एस) = & gt; (1, 0)  
 
 यह तब तक काम करता है जब तक एल नहीं होता है जैसा कि आप देख सकते हैं, मैं ट्रेस और चड्डी को अलग-अलग सूचियों में अलग कर देता हूं और लंबाई लौटाता हूं। हालांकि, एल 'अन्य पत्ते और चड्डी शामिल कर सकते हैं जो गिना नहीं जा रहे हैं सूचना यह पुनरावर्ती नहीं है मैं निरंतरता का उपयोग करने की कोशिश करने की सोच रहा हूं, लेकिन मैं ऐसा नहीं जानता कि ऐसा कैसे करना है। किसी भी सुझाव कृपया? 
 

चूंकि हमारी डेटाटाइप सूचियों से भिन्न है, इसलिए हमें इसके लिए एक स्पष्ट कम समारोह बनाने की आवश्यकता है यह। यह समारोह को कम करता है एक फ़ंक्शन (एफएफ) में ले जाता है जो हर पत्ती पर लागू होता है यह एक फ़ंक्शन (एफडी) में भी लेता है जो हर ट्रंक पर लागू होता है और फिर परिणामस्वरूप परिणाम संयोजन करता है। ऐसा लगता है:

  मजेदार कम (एफएफ: ('एक * स्ट्रिंग - & gt;' बी)) (एफडी: ('ए' * बी सूची - & gt; 'बी')) S: int A): 'b = मामले का पत्ता (ए, डी) = & gt; एफएफ (ए, डी) | ट्रंक (ए, एल) = & gt; Fd (a, list.map (fn x = & gt; कम (ff) (fd) (x)) l)  

अंत में हमारी गिनती कार्य इस तरह दिखेगा:

(Fn x = & gt; 1) (fn (y, l) = 0) ========================================================================= I (I, i ') में वोल i' = कम (fn x = & gt; 0) (fn (y, l) = & gt; 1 + गुच्छा से + 0 l) (ओं) (I) यदि कोई पत्ता पाया जाता है तो इसे 1 के साथ बदलें और यदि कोई ट्रंक पाया जाता है तो इसे 0 से बदलें और पूरी सूची को जोड़ दें। (आई ') में, यदि कोई पत्ती पाया गया तो उसे 0 के साथ बदलें। अन्यथा यदि 1 ट्रंक मिला हो और जोड़! योग