Currying गणित ऑपरेटर्स स्काला

Question

में मैं प्रासंगिक कार्यों के लिए गणित ऑपरेटरों से एक सरल मानचित्र बनाना चाहते हैं:

var ops = Map("+" -> +, "-" -> -) 

मैं कैसे स्काला में यह करना होगा?

Answer 1

val ops = Map("+" -> ((_: Int) + (_: Int)), "-" -> ((_: Int) - (_:Int))) 

या

val ops = Map[String, (Int, Int) => Int]("+" -> (_+_), "-" -> (_-_)) 

या यहाँ तक कि, वास्तविक currying के लिए,

val ops = Map("+" -> ((_: Int) + (_: Int)).curried, "-" -> ((_: Int) - (_:Int)).curried) 

इन कार्यों Int करने के लिए सभी बाँध कर रहे हैं। खैर, स्कैला एक बिंदु-मुक्त प्रोग्रामिंग भाषा नहीं है, यह एक ऑब्जेक्ट उन्मुख है, और एक जिसमें सभी संख्यात्मक प्रकारों के लिए कोई सुपरक्लास सामान्य नहीं है। वैसे भी, यदि आप उस पर ऑब्जेक्ट करते हैं, तो आपके पास एक पूरी तरह से अलग समस्या है, जिसे पूछा गया था और स्टैक ओवरफ़्लो पर कई बार जवाब दिया गया था (वास्तव में, यह मेरा पहला स्कैला प्रश्न था, आईआईआरसी)।

Answer 2

यदि आप कार्यों को घुमाने के लिए चाहते हैं, तो संभवतः यह करने का सबसे संक्षिप्त तरीका निम्नलिखित है।

scala> val ops: Map[String, Int => Int => Int] = Map(
    | "+" -> (x => y => x + y), 
    | "-" -> (x => y => x - y) 
    |) 
ops: Map[String,Int => Int => Int] = Map(+ -> <function1>, - -> <function1>) 

यह मानचित्र हालांकि Int एस तक सीमित है। यदि आप जेनेरिक ऑपरेशंस चाहते हैं, तो आपको Numeric संदर्भ बाध्य का उपयोग करना होगा।

scala> def ops[N : Numeric]: Map[String, N => N => N] = { 
    | import Numeric.Implicits._ 
    | Map(
    |  "+" -> (x => y => x + y), 
    |  "-" -> (x => y => x - y) 
    | ) 
    | } 
ops: [N](implicit evidence$1: Numeric[N])Map[String,N => N => N] 

इस दृष्टिकोण के साथ एक प्रमुख चेतावनी है कि एक नक्शा हर बार जब आप ops फोन बनाया जाता है।