Question

在F＃中，我有一个非常长的代码文件，如

    let rec f1 a1 a2 a3 a4 a5 .. aN =
            ...

    and f2 a1 a2 a3 a4 a5 ... aN =
            ...
    and f3 a1 a2 a3 a4 a5 ... aN =
            ...



    and f40 a1 a2 a3 a4 a5 ... aN =
            ...

换句话说，有许多相互递归的函数，每个函数都有很多参数。

现在的问题是文件长度为17000行，而Visual Studio变得太慢了。（例如，我不能将鼠标悬停在某个项目上以查看其类型;如果我按下该点，则表示没有完成，依此类推）

因此我需要将文件拆分成许多较小的文件。但我看不到一种机械而简单的方法。

你可以给我一个建议吗？我想用一种机械的方法将代码分成多个文件，这不涉及编写所有函数的类型（保留类型推断）。

Answer 1

与此同时，我找到了一个解决方案（已测试）：

这是最初的情况（简化为只有四个功能，但实际上它们还有更多）：

    let rec f1 a b c  =

            f2 a b c;
            f3 a b c;
            f4 a b c;



    and f2 a b c  =

            f1 a b c;
            f3 a b c 
            f4 a b c 

    and f3 a b c  =

            f1 a b c;
            f2 a b c 
            f4 a b c 


    and f4 a b c  =
            f1 a b c;
            f2 a b c 
            f3 a b c

这是解决方案：

假设您决定将f3移动到另一个文件。然后，您可以将上面的文件拆分为两个文件，如下所示：

    FILE 1
    ======


    let callRef mf =
            match !mf with
            | None -> failwith "function ref is none"
            | Some f -> f

    let r_f3 = ref None;

    let rec f1 a1 a2 a3  =

            f2 a b c;
            callRef r_f3 a1 b1 c1;
            f4 a1 b1 c1;



    and f2 a1 a2 a3  =

            f1 a b c;
            callRef r_f3 a1 b1 c1;
            f4 a1 b1 c1;



    and f4 a1 a2 a3 =
            f1 a b c;
            f2 a1 b1 c1;
            callRef r_f3 a1 b1 c1;





    FILE 2
    ======

    let  f3 a1 a2 a3  =

            f1 a b c;
            f2 a1 b1 c1;                               
            f4 an bn cn;

然后，在主初始化函数（在第三个文件中）中，您需要执行

 r_f3 := Some f3;

就是这样。

重复相同的策略，将f1，f2和f4移出第一个文件。

更新：此解决方案适用于返回单位的函数，但不幸的是，对于返回实际类型的函数，它会强制您明确指定函数类型，例如

let (r_f3 : (t1 -> t2 -> t3 -> t4 -> t5) option ref)  = ref None;

或者你可以这样做：

let (r_f3 : 'a option ref)  = ref None;

但是你会得到一个编译器警告。

拆分具有相互递归功能的巨大F＃文件

1 个答案: