चिकनी तरीका है? काम ज्यादातर लोगों पर

Question

यहाँ, जावा का उपयोग करते समय मैं स्काला के साथ काम कर रहा हूँ। हमने पुस्तकालय में कुछ सामान्य कक्षाएं इकट्ठा करने का निर्णय लिया है जो जावा में लिखे जाएंगे।

जावा:

public interface Func<A, R> { 
    public R f(a A); 
} 

public AClass { 
    public <R> ArrayList<R> myMethod(
          Func<String, R> func 
    ) { 
     // ... 
    } 
} 

जावा में उपयोग:

AClass ac = new AClass(); 
ArrayList<String> al = ac.myMethod(
          new Func<String, String> (
           public String f(String s) { 
            return s + "!"; 
           } 
          }) 

ऊपर बिल्कुल नहीं है अब मैं, पुस्तकालय के लिए कुछ छद्म कार्यात्मक प्रोग्रामिंग जोड़ने के निम्नलिखित पर एक नज़र लेने के लिए बाहर निकलना (वास्तव में एक स्केल परिप्रेक्ष्य से, वास्तव में चुनौतीपूर्ण की तरह)। वहाँ कुछ स्केला जादू को बुलाने के लिए स्केला में निम्नलिखित की तरह कुछ करने के लिए सक्षम होने के लिए कोई तरीका है:

var ac = new ACLass 
var al = ac.myMethod(str => str + "!")    // alternative 1 
al = ac.myMethod { case: str:String => str + "!" } // alternative 2 

मैं थोड़ी देर के लिए implicits के साथ चारों ओर गड़बड़ लेकिन चीजों को हल = पी नहीं मिल सका।

Answer 1

अंतर्निहित रूपांतरण के साथ

:

object FuncConversions { 
    implicit def func2function[A,R](fn: (A) => R) = 
    new Func[A,R] { 
     def f(a: A) = fn(a) 
    } 
} 

अपने दायरे में रूपांतरण आयात करने में न भूलें:

import FuncConversions._ 

तुम भी विपरीत रूपांतरण लागू कर सकते हैं।

Answer 2

निदर्शनात्मक जवाब पर विस्तार करने के लिए। यहां बताया गया है कि आप अंतर्दृष्टि को समझने के बारे में कैसे जाते हैं। जब प्रकार जांच नहीं करते हैं तो लागू रूपांतरण खेलते हैं। जब ऐसा होता है, तो संकलक उपयोग करने के लिए एक निहित रूपांतरण की खोज करेगा ताकि प्रकार मिलान हो।

थोड़ा अपने उदाहरण की सफाई, आरईपीएल में करने के बाद, संकलक आएगा:

scala> ac.myMethod((s:String) => s + "!") 
<console>:9: error: type mismatch; 
found : String => java.lang.String 
required: Func[java.lang.String,?] 
       ac.myMethod((s:String) => s + "!") 

तो संकलक आपको बताता है कि यह एक (String) => (String) पाया लेकिन एक Func[String, ?] की जरूरत है। इसलिए आप पाया प्रकार और आवश्यक प्रकार के बीच एक अंतर्निहित रूपांतरण प्रदान करना चाहते हैं। तो हस्ताक्षर की तरह कुछ होना चाहिए: फिर

implicit def fun2Func(fun: (String) => String): Func[String,String] 

, अगले कदम को एहसास है कि निहित रूपांतरण टाइप ए और आर

एक sidenote पर साथ सामान्यीकृत किया जा सकता है, मुझे आश्चर्य है कि अगर आप चाहते http://code.google.com/p/guava-libraries/ जैसे शेल्फ के कुछ उपयोग करके बेहतर हो।

Answer 3

मैं नहीं जानता कि वास्तव में लेकिन शायद कार्यात्मक जावा http://functionaljava.org/ आप और आपके सहकर्मियों मदद कर सकता है। क्या आप वास्तव में अपने 'छद्म-एफपी' lib में इकट्ठा करने का प्रयास करते हैं?