एफ #

Question

में वृक्ष प्रतिनिधित्व मैं tuples की एक सूची का उपयोग कर एफ # में एक पेड़ को लागू करने की कोशिश कर रहा हूं।
[a] जहां a = (string, [a])
प्रत्येक नोड अपने बच्चों और पत्र-गांठ की एक सूची होगा (name, [])

मैं रिकर्सिवली इस तरह सूची के प्रत्येक स्तर के माध्यम से पुनरावृति करने में सक्षम होना चाहते हैं।

a 
b  e 
c d f g 

हालांकि वे हमेशा बाइनरी पेड़ नहीं होते हैं।

let t2 = [("a", [("b", [("c", []), ("d", [])]), ("e", [("f", []), ("g", [])])])] 

let rec checkstuff tple = 
    match tple with 
    | (_, []) -> true 
    | (node, children) -> 
     List.fold (||) false (List.map checkstuff children) 

मैं:

प्रकार बेमेल। एक
        ('a * 'b list) list
लेकिन एक
        'b list
जिसके परिणामस्वरूप प्रकार दिया उम्मीद अनंत जब ''a' और ''b * 'a list'

एकीकृत होगा वहाँ एक रास्ता मैं कुछ इस तरह कुछ कर सकते हैं या इस तरह tuples की एक पुनरावर्ती सूची के लिए समर्थन नहीं है?

Answer 1

अपने डेटा संरचना थोड़ा बदलने का प्रयास करें:

type Tree = 
    | Branch of string * Tree list 
    | Leaf of string 

let t2 = Branch ("a", [Branch ("b", [Leaf "c"; Leaf "d"]); Branch ("e", [Leaf "f"; Leaf "g"])]) 

let rec checkstuff tree = 
    match tree with 
    | Leaf _ -> true 
    | Branch (node, children) -> 
     List.fold (||) false (List.map checkstuff children) 

Answer 2

के कुछ तरीके हैं इस दृष्टिकोण हैं, और डैनियल अच्छा है। लेकिन यहां एक और तरीका है (भेदभाव वाले यूनियनों का भी उपयोग करना) एक पुनरावर्ती डेटा संरचना को परिभाषित करने के लिए, यह आपके दृष्टिकोण के करीब थोड़ा सा है (हालांकि मुझे लगता है कि मैं वास्तव में डैनियल को पसंद कर सकता हूं क्योंकि मामले अधिक स्पष्ट हैं):

type tree<'a> = 
    | Node of 'a * list<tree<'a>> 

let t3 = Node("a", [Node("b", [Node("c",[]); Node("d",[])]); Node("e", [Node("f",[]); Node("g",[])])]) 

let rec checkstuff tple = 
    match tple with 
    | Node(_, []) -> true 
    | Node(node, children) -> 
     List.fold (||) false (List.map checkstuff children)