घोंसला वाले मानचित्रों का क्लोजर जिपर एक ट्राई

Question

एक ट्राई के लिए क्लोजर जिपर कैसे बना सकता है, जो नेस्टेड मानचित्रों द्वारा दर्शाया गया है, चाबियां हैं।

कुछ इस तरह:

{\b {\a {\n {\a {\n {\a {'$ '$}}}}}} \a {\n {\a {'$ '$}}}} 

2 शब्द 'केला' और 'एना' के साथ एक Trie प्रतिनिधित्व करता है। (यदि आवश्यक हो, तो नक्शे में कुछ बदलाव करना संभव है ..)

मैंने map? vals assoc को क्रमशः जिपर के 3 कार्यों के रूप में पास करने का प्रयास किया है। लेकिन यह काम नहीं कर रहा है ..

मुझे किस 3 कार्यों का उपयोग करना चाहिए?

और जिपर पर आधारित डालने-इन-ट्राई कैसा दिखता है?

Answer 1

map?vals#(zipmap (keys %1) %2) करना होगा, लेकिन बच्चों की प्रविष्टि/हटाने का समर्थन नहीं करता (के बाद से बच्चों को केवल मान होते हैं, आप जो कुंजी को हटाने/जोड़ने के लिए पता नहीं है)।

map-zipper नीचे प्रविष्टि/निष्कासन का समर्थन करता है क्योंकि नोड्स [के वी] जोड़े हैं (रूट जो रूट है) को छोड़कर।

(defn map-zipper [m] 
    (z/zipper 
    (fn [x] (or (map? x) (map? (nth x 1)))) 
    (fn [x] (seq (if (map? x) x (nth x 1)))) 
    (fn [x children] 
     (if (map? x) 
     (into {} children) 
     (assoc x 1 (into {} children)))) 
    m)) 

Answer 2

solution proposed by @cgrant महान है, लेकिन परोक्ष एक पेड़ जहां सभी शाखाओं और पत्र-गांठ रूट नोड कि एक मूल्य के बिना ही एक शाखा है के अलावा एक संबद्ध मूल्य (शब्दकोश में कुंजी) है वर्णन करता है। तो, पेड़ {"/" nil}, एक पत्ती नोड वाला पेड़ नहीं है, लेकिन एक अज्ञात रूट शाखा वाला पेड़ और / मूल्य वाला एक पत्ता नोड है। प्रैक्टिस में, इसका मतलब है कि पेड़ के हर ट्रैवर्सल को रूट नोड को उतरने के लिए पहले (zip/down t) निष्पादित करना होगा।

एक वैकल्पिक समाधान मानचित्र के अंदर रूट को स्पष्ट रूप से मॉडल करना है, यानी रूट पर एक ही कुंजी वाले मानचित्रों से केवल ज़िप्पर बनाएं। उदाहरण के लिए:

(defn map-zipper [map-or-pair] 
    "Define a zipper data-structure to navigate trees represented as nested dictionaries." 
    (if (or (and (map? map-or-pair) (= 1 (count map-or-pair))) (and (= 2 (count map-or-pair)))) 
    (let [pair (if (map? map-or-pair) (first (seq map-or-pair)) map-or-pair)] 
     (zip/zipper 
     (fn [x] (map? (nth x 1))) 
     (fn [x] (seq (nth x 1))) 
     (fn [x children] (assoc x 1 (into {} children))) 
     pair)) 
    (throw (Exception. "Input must be a map with a single root node or a pair."))))