डिबगिंग एफ # कोड और कार्यात्मक शैली

Question

मैं funcctional प्रोग्रामिंग करने के लिए नया हूँ और कोडिंग शैली और डिबगिंग के बारे में कुछ सवाल हैं।

मैं धारणा के तहत कर रहा हूँ कि एक अस्थायी चर में funcction कॉल से परिणाम के भंडारण से बचना चाहिए और फिर उस चर लौट

उदा

let someFunc foo = 
    let result = match foo with 
       | x -> ... 
       | y -> ... 
    result 

और बजाय इस तरह यह कर (मैं जिस तरह से बंद हो सकता है?):

let someFunc foo = 
    match foo with 
    | x -> ... 
    | y -> ... 

जो एक functionallity नजरिए से ठीक काम करता है, लेकिन यह यह डिबग करने के लिए रास्ता कठिन बना देता है। मेरे पास परिणाम की जांच करने का कोई तरीका नहीं है यदि - दाएं हाथ की ओर -> कुछ फंकी चीजें करता है।

तो मैं परिदृश्यों के इस प्रकार के साथ कैसे पेश आना चाहिए?

Answer 1

किसी भी तरह से, स्वीकार्य है।

हालांकि एक पकड़ है। आप एक पुनरावर्ती पाश के हिस्से के रूप में प्रयोग करते हैं पूंछ कॉल का उपयोग, अस्थायी चर का उपयोग कर एक पूंछ कॉल समाप्त करेंगे, और इसलिए आप ढेर अंतरिक्ष में वृद्धि करनी होगी।

Answer 2

यदि आप अस्थायी इस्तेमाल किया मैं तुम्हें गोली मार नहीं होगा, लेकिन मैं भी बंद मौका है कि मैं डिबग के तहत कुछ देखने के लिए की जरूरत पर मेरी शैली के लिए कोई परेशानी नहीं होगी। के रूप में आप प्रत्येक संभव मैच अभिव्यक्ति के अंदर breakpoints उपयोग कर सकते हैं

इसके अलावा, बात इस तरह की डिबगिंग दृश्य स्टूडियो 2010 का दृश्य डीबगर के साथ बहुत आसान है,। त्वरित घड़ी और अन्य महान सुविधाएं भी हैं।

विजुअल स्टूडियो डीबगर में नवीनतम सुविधाओं की सूची के लिए: के रूप में आप केवल स्थानीय अपरिवर्तनीय चर के लिए बाध्य कर रहे हैं http://msdn.microsoft.com/en-us/library/01xdt7cs.aspx

Answer 3

वी.एस. में एक समारोह के रिटर्न मान देखने के लिए सक्षम होने के नाते एक लंबे समय से अनुरोध है। अन्य मध्यवर्ती अभिव्यक्ति मूल्य भी; उदाहरण के लिए एफ # में, आप अक्सर एक पाइपलाइन के बीच का निरीक्षण करना चाहते हैं, जो करना मुश्किल है। इस अर्थ में कि कार्यात्मक प्रोग्रामिंग का अर्थ है "कम नामित चर और स्थानीय" और "बड़े अभिव्यक्ति", इसका वर्तमान पीढ़ी के डिबगर्स पर नकारात्मक प्रभाव पड़ता है। (दूसरी ओर, कम अस्थिरता और उच्च अमूर्त आदि के संबंध में, उम्मीद है कि आप कम समय डीबगर में खर्च करते हैं।)

अभी भी कई तरह से भविष्य की डिबगर सुधार किया जा सकता है ...

देखें भी

Do some Functional programming constructs reduce Debuggability?

Answer 4

एक पाइप लाइन के बीच का निरीक्षण करने के लिए, मेरा सुझाव है निम्नलिखित वैकल्पिक हल:

कुछ जगह पर यह कोड डालें:

[<AutoOpen>] 
module AutoOpenModule 

#if DEBUG 
let (|>) value func = 
    let result = func value 
    result 
#endif 

"प्रबंधित कोड में गुण और ऑपरेटरों में कदम" सक्षम:

https://msdn.microsoft.com/en-us/library/cc667388(v=vs.100).aspx

अब आप पाइपलाइन ऑपरेटर में कदम करने के लिए सक्षम होना चाहिए।