बुनियादी बीजगणितीय सरलीकरण को लागू करने के लिए भेदभाव संघ का उपयोग करना F #

Question

मैं बीजगणितीय अभिव्यक्ति को परिभाषित करने के लिए एक भेदभाव संघ का उपयोग कर रहा हूं, और फिर एक सरलीकरण समारोह को कार्यान्वित कर रहा हूं जो एक पुनरावर्ती मैच-केस एल्गोरिदम के साथ मूल बीजगणितीय सरलीकरण करता है। मैं नेस्टेड अतिरिक्त/घटाव/गुणा शामिल एक रोडब्लॉक में भाग गया।

मुद्दा यह है कि दो या दो से अधिक नेस्टेड Expression ऑब्जेक्ट्स जोड़ने/घटाने/मिलान करने के लिए मैच-केस ऑब्जेक्ट को एक ही स्थिरता तक नीचे तक सरल नहीं करेगा। आईई:

simplify Add(Add(Const(1), Const(2)), Add(Const(1), Const(2)))

Add(Const(3), Const(3)) युक्त एक Expression वस्तु देता है जब यह मैं केवल अतिरिक्त के लिए मामलों को शामिल किया, जिसमें एक Const(6)

निम्नलिखित कोड क्या बहुत स्पष्ट हो रहा है कर देगा लौटना चाहिए, संक्षिप्तता के लिए, के बाद से संरचना (और समस्या) घटाव और गुणा के लिए समान है:

// Expression type 
type Expression = 
    | X 
    | Y 
    | Const of float 
    | Neg of Expression 
    | Add of Expression * Expression 
    | Sub of Expression * Expression 
    | Mul of Expression * Expression 

let rec simplify expr = 
    match expr with 
    | X -> expr 
    | Y -> expr 
    | Const(n) -> Const(n) 
    | Add(X, Const(0.0)) -> X 
    | Add(Const(0.0), X) -> X 
    | Add(Const(0.0), Y) -> Y 
    | Add(Y, Const(0.0)) -> Y 
    | Add(Const(n1), Const(n2)) -> Const(n1+n2)     // PROBLEM_1 
    | Add(expr1, expr2) -> Add(simplify(expr1), simplify(expr2)) // PROBLEM_2 

समस्या यह है कि जिस तरह से यह वर्तमान में संरचित है, // PROBLEM_2 से मेल खाता एक इनपुट // PROBLEM_1 मामले को पूरी तरह से पुन: सक्रिय नहीं करेगा, भले ही expr1 और expr2 में केवल Const मान हों। जैसा कि ऊपर उल्लेख, यह अंततः एक Expression-> Add(Const(n2), Const(n2)) युक्त बजाय वास्तव में उन अंतिम दो मानों को एक साथ जोड़ने -> Const(n1+n2)

में के रूप में मैं जिस तरह से यह संरचित है ताकि Add(expr1, expr2) घटना में एक भी Const वापस आ जाएगी के बारे में क्या बदल सकते हैं वापस आ जाएगी कि कि सभी उप अभिव्यक्तियों में Const मानों को कम किया गया है, यानी: जिनमें कोई चर या irreducible अभिव्यक्ति नहीं है?

Answer 1

मैं अंतिम पंक्ति केवल परिवर्तन की आवश्यकता है

| Add(expr1, expr2) -> simplify(Add(simplify(expr1), simplify(expr2))) 
//      ^^^^^^^^^         ^

करने के लिए बदल लगता है?