F #

Question

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

1) पुनरावर्ती क्रिया

let rec doSomethingElse x = 
    let doSomething n = ... 
    match x with 
    | yourDone -> ... 
    | yourNotDone -> doSomethingElse (doSomething x) 

3 अंदर पुनरावर्ती क्रिया

let doSomething n = ... 
let rec doSomethingElse x = 
    match x with 
    | yourDone -> ... 
    | yourNotDone -> doSomethingElse (doSomething x) 

2) के बाहर)

let doSomethingElse x = 
    let doSomething n = ... 
    let innerDoSomethingElse = 
     match x with 
     | yourDone -> ... 
     | yourNotDone -> innerDoSomethingElse (doSomething x) 

4) कुछ भी एक तिहाई समारोह के अंदर दोनों संपुटित बेहतर है?

Answer 1

module Test = 

    let f x = 
     let add a b = a + b //inner function 
     add x 1 

    let f2 x = 
     let add a = a + x //inner function with capture, i.e., closure 
     add x 

    let outerAdd a b = a + b 

    let f3 x = 
     outerAdd x 1 

अनुवाद करता है:

[CompilationMapping(SourceConstructFlags.Module)] 
public static class Test { 

    public static int f(int x) { 
     FSharpFunc<int, FSharpFunc<int, int>> add = new add@4(); 
     return FSharpFunc<int, int>.InvokeFast<int>(add, x, 1); 
    } 

    public static int f2(int x) { 
     FSharpFunc<int, int> add = new add@8-1(x); 
     return add.Invoke(x); 
    } 

    public static int f3(int x) { 
     return outerAdd(x, 1); 
    } 

    [CompilationArgumentCounts(new int[] { 1, 1 })] 
    public static int outerAdd(int a, int b) { 
     return (a + b); 
    } 

    [Serializable] 
    internal class add@4 : OptimizedClosures.FSharpFunc<int, int, int> { 
     internal add@4() { } 

     public override int Invoke(int a, int b) { 
      return (a + b); 
     } 
    } 

    [Serializable] 
    internal class add@8-1 : FSharpFunc<int, int> { 
     public int x; 

     internal add@8-1(int x) { 
      this.x = x; 
     } 

     public override int Invoke(int a) { 
      return (a + this.x); 
     } 
    } 
} 

एक आंतरिक समारोह के लिए केवल अतिरिक्त लागत FSharpFunc का एक उदाहरण ऊपर new'ing है नगण्य --seems।

जब तक आप बहुत प्रदर्शन संवेदनशील नहीं हैं, तो मैं उस दायरे के साथ जाऊंगा जो सबसे अधिक समझ में आता है, यानी, सबसे संकीर्ण दायरा संभव है।