स्कैला

Question

में कार्यात्मक कोड डिबगिंग कार्यात्मक कोड डिबगिंग अनिवार्य कोड डीबग करने से निश्चित रूप से अधिक कठिन है। चर्चा here, here और here देखें। "कार्यात्मक" डिबगिंग को कार्यों/बंद/monads के वापसी मूल्य का निरीक्षण करने का समर्थन करना चाहिए। क्या किसी भी डिबगर्स/आईडीई में इंटरमीडिएट रिटर्न वैल्यू का निरीक्षण करने की क्षमता है (योजना है)?

उदाहरण के लिए, स्काला में इस लाइन डिबग करने के लिए, मैं r

val r=(ls filter (_>1) sort (_<_) zipWithIndex) filter {v=>(v._2)%2==0} map{_._1} 

Answer 1

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

:

val ls = List(1,2,3).map(_ * 2) 
       .tap(soFar => println("So far: " + soFar)) 
       .map(_ * 2) 
println(ls) 

यह बाहर प्रिंट होगा: सूची (2, 4, 6)
सूची (4, 8, 12)

यह मुझे हर एक बार थोड़ी देर में मदद करता है।

Answer 2

मैं संक्षिप्त जा रहा है पता बहुत अच्छा है लौटने से पहले 4 समारोह आमंत्रण के माध्यम से कदम और हर कदम पर दिए गए मान का निरीक्षण करने के लिए सक्षम होना चाहिए, और मैं आपसे सहमत हूं कि इन स्थितियों में आईडीई को डीबगिंग में मदद करनी चाहिए। लेकिन समय के लिए मैंने डीबगिंग में सहायता के लिए अपनी कोडिंग शैली बदल दी है। मेरी व्यक्तिगत शैली में मैं अपने उदाहरण से लागू किया जाएगा है के रूप में:

val noZeroLs = ls.filter(_>1) 
val sortedLs = noZeroLs.sort(_<_) 
val indexedNoZeroLs = sortedLs.zipWithIndex 
val everySecondIndexedL = indexedNoZeroLs.filter(v => (v._2) % 2 == 0) 
val everySecondL = everySecondIndexedL.map(_._1) 

सार्थक नाम के साथ आ रहा है मुश्किल/श्रमसाध्य है, लेकिन यह आप मूर्ख कीड़े की पहचान में मदद करता है, दूसरों को यह समझने में मदद कर सकता है कि क्या हो रहा है; और निश्चित रूप से डीबगिंग के साथ मदद करता है।

Answer 3

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

अच्छे और उपयोग में आसान परीक्षण टूलकिट के साथ युग्मित करने के लिए प्रतिलिपि का उपयोग करने की क्षमता ने मेरे लिए अप्रचलित लेकिन सभी को डिबगर्स बना दिया है।

बेशक वाईएमएमवी।

Answer 4

पूरी तरह से कार्यात्मक सेटिंग में, चरणबद्ध करना उतना ही उपयोगी नहीं है जितना आप सोच सकते हैं। चूंकि सबकुछ शुद्ध कार्यों से बना है, इसलिए आप उन्मूलन की प्रक्रिया का उपयोग करके व्यक्तिगत रूप से उन टुकड़ों का परीक्षण कर सकते हैं। एक आलसी मूल्यांकन सेटिंग में, कोड के माध्यम से कदम कम भी उपयोगी है।

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

Answer 5

यह उपयोगी है जब आप अपने खुद के कोड डिबग करने के लिए प्रयास करते हैं, लेकिन स्केला लैंग या अन्य libs डिबगिंग के दौरान आप कोड :(

Answer 6

आप एक IDE की जरूरत नहीं है, तो भी आप इस उपकरण का उपयोग कर सकते हैं परिवर्तित नहीं कर सकता मैं लिखा है:

https://github.com/JohnReedLOL/scala-trace-debug

मध्यस्थ मूल्यों मुद्रित करने के लिए, तो आप इस उदाहरण ले सकते हैं:

val result=(lists.filter(_>1).sort(_<_).zipWithIndex).filter{v=>(v._2)%2==0}.map{_._1} 

और यह करने के लिए निशान जोड़ें:

import scala.trace.implicitlyTraceable 
val result=(lists.filter(_>1).out.sort(_<_).println.zipWithIndex).filter{v=>(v._2)%2==0}.out.map{_._1}.out 

एक निहित रूपांतरण आपको प्रिंट करने की अनुमति देता है।