साइड-इफेक्टिंग मोनड

Question

का परीक्षण कानून मैं एपीआई के माध्यम से वेब सेवा तक पहुंचने के लिए एक लाइब्रेरी लिख रहा हूं। मैं एपीआई कार्रवाई

case class ApiAction[A](run: Credentials => Either[Error, A]) 

प्रतिनिधित्व करने के लिए साधारण क्लास परिभाषित किया है और कुछ कार्यों कि वेब सेवा करता कॉल

// Retrieve foo by id 
def get(id: Long): ApiAction[Foo] = ??? 

// List all foo's 
def list: ApiAction[Seq[Foo]] = ??? 

// Create a new foo 
def create(name: String): ApiAction[Foo] = ??? 

// Update foo 
def update(updated: Foo): ApiAction[Foo] = ??? 

// Delete foo 
def delete(id: Long): ApiAction[Unit] = ??? 

मैं भी ApiAction एक इकाई द्वारा किए गए

implicit val monad = new Monad[ApiAction] { ... } 

तो मैं कर सकता

create("My foo").run(c) 
get(42).map(changeFooSomehow).flatMap(update).run(c) 
get(42).map(_.id).flatMap(delete).run(c) 

जैसे कुछ करें

अब मैं मुसीबतों अपनी इकाई कानूनों का परीक्षण

val x = 42 
val unitX: ApiAction[Int] = Monad[ApiAction].point(x) 

"ApiAction" should "satisfy identity law" in { 
    Monad[ApiAction].monadLaw.rightIdentity(unitX) should be (true) 
} 

क्योंकि monadLaw.rightIdentityequal

def rightIdentity[A](a: F[A])(implicit FA: Equal[F[A]]): Boolean = 
    FA.equal(bind(a)(point(_: A)), a) 

का उपयोग करता है और वहाँ कोई Equal[ApiAction] है।

[error] could not find implicit value for parameter FA: scalaz.Equal[ApiAction[Int]] 
[error]  Monad[ApiAction].monadLaw.rightIdentity(unitX) should be (true) 
[error]           ^

समस्या मैं कल्पना भी नहीं कर सकते हैं कि यह कैसे Equal[ApiAction] को परिभाषित करना संभव हो सकता है। ApiAction एक कार्य अनिवार्य है, और मुझे कार्यों पर किसी भी समानता संबंध के बारे में पता नहीं है। बेशक ApiAction चलाने के परिणामों की तुलना करना संभव है, लेकिन यह वही नहीं है।

मुझे लगता है कि मैं कुछ गलत कर रहा हूं या कुछ आवश्यक समझ नहीं पा रहा हूं। तो मेरे प्रश्न हैं:

• क्या यह ApiAction के लिए एक मोनड होने के लिए समझ में आता है?
• क्या मैंने ApiAction सही बनाया है?
• मुझे अपने मोनैड कानूनों का परीक्षण कैसे करना चाहिए?

Answer 1

मैं आसान लोगों से शुरू करूंगा: हां, यह ApiAction के लिए एक मोनड होने के लिए समझ में आता है। और हाँ, आपने इसे उचित तरीके से डिज़ाइन किया है - यह डिज़ाइन हास्केल में IO मोनैड जैसा दिखता है।

मुश्किल सवाल यह है कि आपको इसका परीक्षण कैसे करना चाहिए।

एकमात्र समानता संबंध जो समझ में आता है वह "समान इनपुट के समान उत्पादन उत्पन्न करता है", लेकिन यह केवल कागज पर वास्तव में उपयोगी है, क्योंकि कंप्यूटर के सत्यापन के लिए यह संभव नहीं है, और यह शुद्ध कार्यों के लिए केवल सार्थक है। दरअसल, हास्केल का IO मोनैड, जिसमें आपके मोनैड की कुछ समानताएं हैं, Eq लागू नहीं करती हैं। तो यदि आप Equal[ApiAction] लागू नहीं करते हैं तो शायद आप सुरक्षित जमीन पर हैं।

फिर भी, परीक्षण में केवल उपयोग के लिए विशेष Equal[ApiAction] उदाहरण लागू करने के लिए एक तर्क हो सकता है, जो हार्ड-कोडित Credentials मान (या हार्ड-कोडित मानों की एक छोटी संख्या) के साथ कार्रवाई चलाता है और परिणामों की तुलना करता है। सैद्धांतिक दृष्टिकोण से, यह सिर्फ भयानक है, लेकिन व्यावहारिक दृष्टिकोण से यह परीक्षण मामलों के साथ परीक्षण करने से भी बदतर नहीं है, और आपको स्कालाज़ से मौजूदा सहायक कार्यों का पुन: उपयोग करने देता है।

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

Answer 2

मुझे लगता है कि आप इसे अपने वर्ग को एक कक्षा में लपेटने के लिए मैक्रो या प्रतिबिंब का उपयोग करने के नकारात्मक पक्ष के साथ कार्यान्वित कर सकते हैं जिसमें एएसटी शामिल है। फिर आप अपने एएसटी की तुलना करके दो कार्यों की तुलना कर सकते हैं।

What's the easiest way to use reify (get an AST of) an expression in Scala?

Answer 3

देखें यह lambdas FunctionN, जहाँ आप केवल उदाहरण समानता है की अनाम उपवर्गों किया जा रहा करने पर निर्भर करता है, तो केवल एक ही Anonymus उपवर्ग के साथ ही बराबर है।

आप इसे कैसे कर सकता है में से एक विचार: अपने संचालन के बजाय उदाहरणों Function1 की ठोस उपवर्गों करें:

abstract class ApiAction[A] extends (Credentials => Either[Error, A]) 
// (which is the same as) 
abstract class ApiAction[A] extends Function1[Credentials, Either[Error, A]] 

कौन सा उदाहरण बनाने के लिए मामला अपने मामलों के लिए वस्तुओं के लिए आप की अनुमति होगी

case class get(id: Long) extends ApiAction[Foo] { 
    def apply(creds: Credentials): Either[Error, Foo] = ... 
} 

और इसके बदले में आप एपिएक्शन के प्रत्येक उप-वर्ग के लिए बराबर लागू करने की अनुमति दे सकते हैं, उदाहरण के लिए, कन्स्ट्रक्टर के पैरामीटर पर।(आप कि मुक्त बनाने के लिए आपरेशन मामले वर्गों मिल सकता है, जैसे मैंने किया)

val a = get(1) 
val b = get(1) 
a == b 

तुम भी मैं की तरह Function1 के विस्तार के बिना ऐसा कर सकता है किया था और जैसे तुमने किया था एक रन फ़ील्ड का उपयोग, लेकिन इस तरह से सबसे दिया succint उदाहरण कोड।