Каковы побочные эффекты производительности определения функций внутри рекурсивной функции против внешней в F # - PullRequest
Новая
       20

Каковы побочные эффекты производительности определения функций внутри рекурсивной функции против внешней в F #

6 голосов
/ 27 октября 2011

Если у вас есть рекурсивная функция, которая опирается на какую-то другую функцию, какой предпочтительный способ ее реализации?

1) вне рекурсивной функции 

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

2) внутри рекурсивнойфункция 

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

3) инкапсулировать оба внутри третьей функции 

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

4) что-то еще лучше?

1 Ответ

5 голосов
/ 27 октября 2011 
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 - кажется незначительным.

Если только вы не очень чувствительны к производительности, я бы выбрал сферу, которая имеет наибольший смысл, то есть максимально узкую область.

...