क्या स्काला में बने हास्केल के 'शायद' समारोह की तरह कुछ भी है?

Question

जो मैं ढूंढ रहा हूं वह यह फ़ंक्शन है:

def maybe[A, B](a: Option[A])(f: A => B)(g:() => B): B = a match 
{ 
    case Some(x) => f(x) 
    case None => g() 
} 

यह हास्केल प्रस्ताव में है इसलिए मुझे लगता है कि यह कहीं भी स्कैला मानक लाइब्रेरी में हो सकता है और मैंने इसे अभी याद किया है। मुझे परियोजनाओं में इसे दोबारा नफरत करने से नफरत है इसलिए मुझे आश्चर्य है कि अगर कोई जानता है कि यह कहां है, या यदि यह निश्चित रूप से वहां नहीं है। या क्या यह कार्यक्षमता प्राप्त करने के लिए एक बेहतर तरीका है?

Answer 1

आप कर सकता है

val opt:Option[A] = // ... 
val result:B = opt.map(f).getOrElse(g()); 

getOrElse एक उप-नाम पैरामीटर लेता है, तो g केवल मूल्यांकन किया जाएगा यदि optNone है।

Answer 2

मुझे नहीं लगता कि वहां है। सबसे अच्छा मैं के साथ आ सकता है श्रृंखला विकल्प की 'नक्शा' और 'getOrElse "एक साथ करने के लिए है:

scala> var a: Option[String] = Some("hello") 
a: Option[String] = Some(hello) 

scala> a.map(_.toUpperCase).getOrElse("empty") 
res19: java.lang.String = HELLO 

scala> a = None 
a: Option[String] = None 

scala> a.map(_.toUpperCase).getOrElse("empty") 
res21: java.lang.String = empty 

Answer 3

मुझे नहीं लगता कि वहाँ है। हालांकि, मैं इसे लिखने के नाम से g लेने के लिए चाहते हैं:

def maybe[A, B](a: Option[A])(f: A => B)(g: => B): B = a.map(f).getOrElse(g) 

यह और अधिक Scala- और हास्केल की तरह और थोड़ा उपयोग करने के लिए अच्छे है।

Answer 4

अन्य उत्तरों ने map + getOrElse संरचना दी है। बस रिकार्ड के लिए, आप Option करने के लिए एक maybe समारोह "जोड़ें" कर सकते हैं निम्नलिखित तरीके से:

implicit def optionWithMaybe[A](opt: Option[A]) = new { 
    def maybe[B](f: A=>B)(g: =>B) = opt map f getOrElse g 
} 

यह ध्यान देने योग्य है कि स्काला में उच्च क्रम कार्यों की वाक्य रचना जब समारोह पैरामीटर पिछले आता है आमतौर पर अच्छे है लायक है। इस प्रकार, व्यवस्थित करने के लिए maybe होगा एक बेहतर तरीका इस प्रकार है:

val opt: Option[String] = ... 
opt.maybe("") { _.toUpperCase } 

Answer 5

विधि गुना कहा जा सकता है अगर यह सम्मेलन का पालन करने के लिए गए थे (या तो देखें:

def maybe[B](g: =>B)(f: A=>B) = opt map f getOrElse g 

यह इस प्रकार किया जा सकता है । फोल्ड जो या तो के लिए catamorphism है)।

Answer 6

आप scalaz उपयोग कर सकते हैं, और फिर आप OptionW जो fold है करने के लिए एक अंतर्निहित रूपांतरण है, या आप स्काला 2.10.0-एम 3 का उपयोग करें और का उपयोग builtin Option.fold

scala> Some(1).fold(5)(_ * 2) 
res5: Int = 2 

scala> (None: Option[Int]).fold(5)(_ * 2) 
res7: Int = 5 

ध्यान दें कि scalaz हस्ताक्षर फोल्ड कर सकते हैं fold[X](some: A => X, none: => X) है, जबकि बिल्टिन fold[X](none: => X)(some: A => X) प्रतीत होता है।

Answer 7

मैं इसके लिए Option.fold का उपयोग करेंगे:

opt.fold(g)(f) 

ध्यान दें कि g सिर्फ getOrElse की तरह, द्वारा-नाम है। मामलों के उलटा ध्यान दें।