सिंटेक्स-जागरूक सबस्ट्रिंग प्रतिस्थापन

Question

मेरे पास एक वैध क्लोजर फ़ॉर्म वाला एक स्ट्रिंग है। मैं इसके एक हिस्से को प्रतिस्थापित करना चाहता हूं, बस assoc-in के साथ, लेकिन पूरे स्ट्रिंग को टोकन के रूप में संसाधित करना चाहता हूं।

=> (assoc-in [:a [:b :c]] [1 0] :new) 
[:a [:new :c]] 
=> (assoc-in [:a 
       [:b,, :c]] [1 0] :new) 
[:a [:new :c]] 
=> (string-assoc-in "[:a 
         [:b,, :c]]" [1 0] ":new") 
"[:a 
    [:new,, :c]]" 

मैं string-assoc-in लिखना चाहता हूं। ध्यान दें कि इसके पहले और अंतिम तर्क तार हैं, और यह लाइन ब्रेक और कॉमा रखता है। क्या यह क्लोजर में किया जा सकता है? मुझे मिली सबसे नज़दीकी चीज़ read है जो clojure.lang.LispReader पर कॉल करती है, लेकिन मुझे नहीं पता कि कैसे काम करता है।

मैं इसे क्लोजर स्रोत फ़ाइल पढ़ने के लिए उपयोग करना चाहता हूं और फ़ाइल की संरचना को बनाए रखने के साथ इसे कुछ संशोधनों के साथ प्रदर्शित करना चाहता हूं।

Answer 1

मुझे लगता है यह, काम करना चाहिए पूरी तरह से सामान्य हो सकता है और अपने स्वयं के रीडर/पार्सर की आवश्यकता नहीं:

(defn is-clojure-whitespace? [c] 
    (or (Character/isSpace c) 
     (= \, c))) 

(defn whitespace-split 
    "Returns a map of true -> (maximal contiguous substrings of s 
    consisting of Clojure whitespace), false -> (as above, non-whitespace), 
    :starts-on-whitespace? -> (whether s starts on whitespace)." 
    [s] 
    (if (empty? s) 
    {} 
    (assoc (group-by (comp is-clojure-whitespace? first) 
        (map (partial apply str) 
          (partition-by is-clojure-whitespace? s))) 
     :starts-on-whitespace? 
     (if (is-clojure-whitespace? (first s)) true false)))) 

(defn string-assoc-in [s coords subst] 
    (let [{space-blocks true 
     starts-on-whitespace? :starts-on-whitespace?} 
     (whitespace-split s) 
     s-obj (assoc-in (binding [*read-eval* false] (read-string s)) 
         coords 
         (binding [*read-eval* false] (read-string subst))) 
     {non-space-blocks false} 
     (whitespace-split (pr-str s-obj))] 
    (apply str 
      (if starts-on-whitespace? 
      (interleave space-blocks (concat non-space-blocks [nil])) 
      (interleave non-space-blocks (concat space-blocks [nil])))))) 

उदाहरण:

user> (string-assoc-in "[:a [:b,, :c]]" [1 0] ":new") 
"[:a [:new,, :c]]" 

अद्यतन:

: आउच, एक बग पकड़ा

user> (string-assoc-in "[:a [:b,, :c\n]]" [1 0] ":new") 
"[:a [:new,, :c]]\n" 

अगर इससे कोई फर्क नहीं पड़ता तो मुझे इससे अच्छा लगेगा, लेकिन मुझे लगता है कि मैं हवल ई इसके बारे में कुछ करने और करने के लिए ... sigh

Answer 2

मुझे लगता है कि आप वास्तव में एक रूप में पढ़ना नहीं चाहते हैं और इसका मूल्यांकन करना चाहते हैं? fnparse में Clojure parser है (Fnparse का उपयोग करके क्लोजर में लिखा गया है)। आप स्ट्रिंग से फ़ॉर्म में लाने के लिए इसका उपयोग करने में सक्षम हो सकते हैं, फिर हेरफेर कर सकते हैं, फिर उसे स्ट्रिंग पर वापस रख दें?

(defn string-assoc-in 
    [a b c] 
    (.replaceAll 
    (str 
    (assoc-in (read-string (.replaceAll a ",," ",_,")) b (read-string c))) 
    " _ " ",, ")) 

user> (string-assoc-in "[:a [:b,, :c]]" [1 0] ":new") 
"[:a [:new,, :c]]" 

ध्यान दें कि हम एक आरक्षित प्लेसहोल्डर चरित्र की आवश्यकता होती है (इस मामले में, _) जो आप नहीं चाहते हैं:

Answer 3

आप (पठन-स्ट्रिंग) और कुछ स्ट्रिंग परिवर्तन के संयोजन के साथ ऐसा कर सकता है अपने खोजशब्दों में ये चाल उन लोगों को प्राप्त करने के लिए है, जब पाठक वेक्टर स्ट्रिंग पर क्रंच कर रहा है, फिर उन्हें वापस रखें।

यह नमूना न्यूलाइन को संबोधित नहीं करता है, लेकिन मुझे लगता है कि आप उन्हें उसी तरह से संभाल सकते हैं।

Answer 4

या कोई अन्य विकल्प ANTLRparse the Clojure कोड को एएसटी में उपयोग करना होगा, फिर एएसटी को बदलना होगा, और एक स्ट्रिंग पर वापस निर्यात करना होगा।