如何打破F＃中的函数依赖关系？

Question

I'd like to unit test fun1 without calling fun2.

let fun2() =
    // Some complex function with lots of dependencies.
    1

let fun1() =
    fun2() * 2

What the best way to break the dependency between the two functions?

I've tried a couple of different ways, but they just add clutter.

Pass fun2 into fun1

let fun1(fun2) =
    fun2() * 2

Convert to a class and override

type FunClass() =
    abstract member fun2 : unit -> int
    default x.fun2() = 1

    member x.fun1() =
        x.fun2() * 2

type FunClassMock() =
    override member x.fun2() = 1

Use stategy pattern

type Fun1Class(fun2Class) =

    member x.fun1() =
       fun2Class.fun2() * 2

Use a variable

let fun2Imp() =
    1

let mutable fun2 = fun2Imp

let fun1() =
    fun2() * 2

Is there a cleaner way?

Answer 1

It depends on your usage, but you could do something like this:

let fun2() =
    // Some complex function with lots of dependencies.
    1

let createFun1 fun2 =
    fun () -> fun2() * 2

let fun1 = createFun1 fun2

This is also useful for unit testing since you can test fun1 by simply passing a simple function in for fun2.

Answer 2

It isn't very flexible, but a compiler directive would work.

let fun2() =
  #if TESTING
  1
  #else
  // Some complex function with lots of dependencies.
  #endif

Defining fun2 in separate modules and open ing the needed module is another option.

module Impl =
  let fun2() =
    // Some complex function with lots of dependencies.

module Testing =
  let fun2() = 1

Answer 3

Any way you do it (that I know of, at least) is going to "add clutter". How about something like this?

let fun1() = 
    fun1_impl(fun2)

let fun1_impl(fun2) =
    fun2() * 2

Then, in regular code, use fun1 , and in your tests, use fun1_impl .

Answer 4

In all generality, the argument passing seems the cleanest.

The clutter effect might not be tackled technically, but semantically : it comes from the fact that it seems a bit arbitrary, from the lack of meaning attached to "function1".

Is there may be a higher, more coherent, level that might be more meaningful in your code ?