गो-लांग करी कैसे जा सकते हैं?

Question

कार्यात्मक प्रोग्रामिंग में पसंद करती है हास्केल, मैं समारोह को परिभाषित कर सकते

add a b = a+b 

फिर add 3 एक समारोह है कि एक पैरामीटर ले जाएं और में वापस आ जाएगी 3 + something

मैं यह करने के लिए कैसे कर सकते हैं वापस आ जाएगी?

जब मैं एक से अधिक फ़ंक्शन को परिभाषित करता हूं जो (एक से अधिक) पैरामीटर लेता है, तो क्या मैं इसे केवल एक पैरामीटर दे सकता हूं और एन-1 पैरामीटर लेने वाला दूसरा फ़ंक्शन प्राप्त कर सकता हूं?

अद्यतन:

अपने मूल प्रश्न में अनिश्चित शब्द के लिए खेद है।

मुझे लगता है कि मेरे सवाल का दो qeustions के रूप में कहा जाना चाहिए:

• वहाँ जाओ में आंशिक आवेदन है?
• कैसे काम करते हैं करी?

धन्यवाद मेरे दूसरे प्रश्न को हल करने के लिए केवल 29 और एलेक्स। हालांकि, मैं पहले प्रश्न के बारे में भी उत्सुक हूं।

Answer 1

पिछले जवाब है, जो आप तर्क का एक मनमाना संख्या लेने के लिए अनुमति देता है पर विस्तार करने के लिए: एक समारोह को परिभाषित करते हुए

package main 

import (
    "fmt" 
) 

func mkAdd(a int) func(...int) int { 
    return func(b... int) int { 
     for _, i := range b { 
      a += i 
     } 
     return a 
    } 
} 

func main() { 
    add2 := mkAdd(2) 
    add3 := mkAdd(3) 
    fmt.Println(add2(5,3), add3(6)) 
} 

Answer 2

शायद कुछ की तरह

package main 

import (
    "fmt" 
) 

func mkAdd(a int) func(int) int { 
    return func(b int) int { 
     return a + b 
    } 
} 

func main() { 
    add2 := mkAdd(2) 
    add3 := mkAdd(3) 
    fmt.Println(add2(5), add3(6)) 
} 

Answer 3

आप इसे एक कदम और आगे ले जा सकते हैं टाइप करें और उसके बाद एक विधि जोड़ना।

package main 

import "fmt" 

type Add func(int, int) int 

func (f Add) Apply(i int) func(int) int { 
    return func(j int) int { 
     return f(i, j) 
    } 
} 

func main() { 
    var add Add = func(i, j int) int { return i + j } 
    add3 := add.Apply(3) 
    fmt.Println("add 3 to 2:", add3(2)) 
} 

तुम भी कोशिश कर सकते हैं variadic कार्यों के साथ:

package main 

import "fmt" 

type Multiply func(...int) int 

func (f Multiply) Apply(i int) func(...int) int { 
    return func(values ...int) int { 
     values = append([]int{i}, values...) 
     return f(values...) 
    } 
} 

func main() { 
    var multiply Multiply = func(values ...int) int { 
     var total int = 1 
     for _, value := range values { 
      total *= value 
     } 
     return total 
    } 


    var times2 Multiply = multiply.Apply(2) 
    fmt.Println("times 2:", times2(3, 4), "(expect 24)") 

    // ... and you can even cascade (if assigned the Multiply type) 
    times6 := times2.Apply(3) 
    fmt.Println("times 6:", times6(2, 3, 5, 10), "(expect 1800)") 
} 

आशा इस मदद करता है!