स्केला: एक सामान्य पुनरावर्ती अधिकतम समारोह

Question

मैं स्केला

maximum' :: (Ord a) => [a] -> a 
maximum' [] = error "maximum of empty list" 
maximum' [x] = x 
maximum' (x:xs) = max x (maximum' xs) 

को बंदरगाह के लिए कोशिश कर रहा हूँ इस Haskell अधिकतम समारोह कार्यान्वयन को लागू यह मेरा पहला प्रयास है:

def max[T <: Ordered[T]](list: List[T]): T = list match { 

    case Nil => throw new Error("maximum of empty list") 
    case head :: Nil => head 
    case list => { 
    val maxTail = max(list.tail) 
    if (list.head > maxTail) list.head else maxTail 
    } 
} 


max(List[Int](3,4)) 

लेकिन मैं निम्नलिखित त्रुटि मिलती है :

inferred type arguments [Int] do not conform to method max's type parameter bounds [T <: Ordered[T]] 

मैं आदेश, comprable, इसी तरह के परिणाम के साथ आदि के साथ की कोशिश की ...

012,

क्या गुम है के बारे में कोई विचार?

Answer 1

शायद आप Ordering टाइप क्लास चाहते हैं?

def max[T: Ordering](list: List[T]): T = list match { 
    case Nil => throw new RuntimeException("maximum of empty list") 
    case head :: Nil => head 
    case list => 
    val maxTail = max(list.tail) 
    if (implicitly[Ordering[T]].gt(list.head, maxTail)) list.head else maxTail 
} 

यह है, सब के बाद, कैसे निर्मित max विधि काम करता है:

// From GenTraversableOnce 
def max[A1 >: A](implicit ord: Ordering[A1]): A 

आप चीजों को एक बहुत साफ कर सकते हैं अगर आप ऐसा करते हैं:

def max[T](list: List[T])(implicit ord: Ordering[T]): T = list match { 
    case Nil => throw new RuntimeException("maximum of empty list") 
    case head :: Nil => head 
    case head :: tail => ord.max(head, max(tail)) 
} 

या, आप इसे बढ़ी हुई दक्षता के लिए पूंछ-रिकर्सिव बना सकते हैं (क्योंकि संकलक इसे अनुकूलित करेगा):

def max[T](list: List[T])(implicit ord: Ordering[T]): T = { 
    if (list.isEmpty) 
    throw new RuntimeException("maximum of empty list") 

    @tailrec 
    def inner(list: List[T], currMax: T): T = 
    list match { 
     case Nil => currMax 
     case head :: tail => inner(tail, ord.max(head, currMax)) 
    } 
    inner(list.tail, list.head) 
} 

इसके अलावा, आपको RuntimeException या इसके उप-वर्ग को फेंकना चाहिए, Error नहीं।

Answer 2

ओह, चाहिये

पूछ मैं इस धागे में जवाब मिल गया से पहले बेहतर दिखेगा: https://stackoverflow.com/a/691674/47633

ऐसा लगता है हास्केल के प्रकार वर्गों की तरह स्केला में (DHG के उदाहरण की तरह)

implicits का उपयोग करके लागू तो यह इस तरह समाप्त होता है:

def max[T](list: List[T])(implicit f: T => Ordered[T]): T = { 

def maxElement(value1: T, value2: T): T = if (value1 > value2) value1 else value2 

list match { 
    case Nil => throw new Error("empty list found") 
    case head :: Nil => head 
    case list => maxElement(list.head, max(list.tail)) 
    } 
} 

या कुछ वाक्यात्मक चीनी के साथ, बस

def max[T <% Ordered[T]](list: List[T]): T = list match { 

फिर भी, मुझे लगता है कि संकलक खुद से यह करने के लिए पर्याप्त जानकारी है ...

ps: मैं एक छोटा सा समारोह ...

Answer 3

मैं सिर्फ आए हैं अप prettied इस समाधान के साथ।

def max(xs: List[Int]): Int = { 
    if (xs.isEmpty) 0 
    else { 
     if(xs.head >= max(xs.tail)) xs.head 
     else max(xs.tail) 
    } 
} 

Answer 4

मैं समझने में आसान एक सरल समाधान के साथ आया था। यह एक खाली सूची, केवल एक तत्व के साथ एक सूची, और नकारात्मक संख्या के लिए पूरा करता है।

def max(xs: List[Int]): Int = { 

    if (xs.isEmpty) throw new NoSuchElementException 
    else { 
    def inner(max: Int, list: List[Int]): Int = { 

     def compare(x: Int, y: Int): Int = 
     if (x > y) x 
     else y 

     if (list.isEmpty) max 
     else inner(compare(max, list.head), list.tail) 
    } 
    inner(xs.head, xs.tail) 
    } 
} 

Answer 5

ओपी बिना पैटर्न मिलान और सामान्य प्रकार के रूप में एक ऐसी ही व्यायाम के माध्यम से चला गया, और निम्नलिखित के साथ आया था: स्रोत पर एक नज़र रखने के लिए

def max(xs: List[Int]): Int = { 
    if (xs.isEmpty) throw new NoSuchElementException 

    if (xs.length == 1) 
     return xs.head 
     else 
     return max(xs.head, max(xs.tail)) 
    } 

    def max(x: Int, y: Int): Int = if (x > y) x else y