在Erlang中，有没有办法创建一个空函数？

Question

我正在编写一个 Erlang 函数，它打印给定参数之前的每个偶数。

到目前为止，我已经用这样的防护编写了函数：

printEven(I,N) when I < N ->
  if
    I rem 2 == 0 -> io:format("~p~n",[I]), printEven(I+1,N);
    I rem 2 == 1 -> printEven(I+1,N)
  end;
printEven(I,N) ->
   io:format("Done").

我真的很想让最后一个案例自动退出，而不必在函数中打印任何内容。 我尝试删除它，但是由于递归完成后会抛出错误，因此会发生错误。

我怎样才能做到这一点？ erlang 中有类似“pass”或“yield”关键字的东西吗？

Answer 1

我相信关键字是“ok”

Answer 2

printEven(Start, Stop) when Start =< Stop ->
    case Start rem 2 of
        0 -> io:format("~p~n", [Start]);  %returns ok
        _ -> do_nothing
    end,  
    printEven(Start+1, Stop);
printEven(Start, Stop) when Start > Stop ->
    ok.

case 语句的值可以是 ok 或 do_nothing，但 case 语句不是最后一个表达式，因此它的值不会是第一个子句的返回值函数，并且由于 case 表达式的值未绑定到变量，因此该值将被简单地丢弃。

第一个函数子句中的最后一个表达式实际上是 printEven(Start+1, Stop)，一旦递归到达末尾，该函数调用最终将返回 ok序列并在 Start > 时执行 printEven(Start, Stop) 停止-> ok;

printEven(1, 3) => ?
                   | 
                   V
             printEven(2, 3) => ?
                                | --side effect: output 2
                                V
                         printEven(3, 3) => ?
                                            |
                                            V 
                                      printEven(4, 3) => ok 

填写链上每个函数调用的返回值给出：

printEven(1, 3) =>  ok
                    ^ 
                    |
              printEven(2, 3) => ok
                                 ^ 
                                 |
                         printEven(3, 3) => ok
                                            ^
                                            |
                                      printEven(4, 3) => ok 

Answer 3

这样就可以做到：

printEven(I,N) -> ok.

Answer 4

好的，首先定义函数：

printEven(I,N) when I >= N -> ok;
printEven(I,N)             -> 
   if
    I rem 2 == 0 -> io:format("~p~n",[I]), printEven(I+1,N);
    I rem 2 == 1 -> printEven(I+1,N)
  end.

Erlang 是一种函数式编程语言，并且（根据定义）函数“具有”一个值，因此您将得到“某些东西”。 按照惯例，在完成用于副作用的函数后返回的结果是原子“ok”，这是这里最好使用的。

如果需要，您可以“默默地丢弃”返回值。 当您通过与“不关心”变量（下划线）进行模式匹配来调用函数时，

_ = printEven(3,9),

或者通过在没有模式匹配的情况下调用函数来调用函数时，您可以这样做：

printEven(3,9),

但是，最好始终通过模式匹配来检查返回值当你调用函数时：

ok = printEven(3,9),

这是一个非常好的习惯，因为你将使用很多返回错误代码的库函数，正如你可以从它们的规范中看到的：

@spec funky(X) -> [ok | {error, bad_op} | {error, wig_out}]

如果 funky 有副作用，你想知道它失败了 < strong>now 通过使用模式匹配调用它，这样如果 funky 失败，它就会立即崩溃：

ok = funky(99),

如果将其与 '_' 匹配或忽略返回值，当你的魔力期望 funky 完成他的工作时，它会在 268 行后崩溃，然后就很难找到了。

这就是快乐路径编程，这是 Erlang 中完成的事情。 “让它崩溃”是座右铭。 如果你是 Erlang 新手，你会发现这非常令人不安——就像赤身裸体走来走去。 别担心，拥抱它，这是一件好事。 它导致大量代码“未被编写”。

（您还应该养成将结束递归的子句作为顶部子句的习惯，如下所示 - 当您有一个多子句函数。）

Answer 5

只需返回一个原子。

printEven(I,N) ->; printEven(I,N) -> 完毕。

应该这样做。

Answer 6

您还可以在保护子句中合并对 Even 的测试。 我也更喜欢完成原子技巧 - 它在您的代码中显示它将停止“递归”的函数子句。

printEven(I, N) when I<N, I rem 2 == 0 ->
    io:format("~p is even~n", [I]),
    printEven(I+1, N);
printEven(I,N) when I<N ->
    printEven(I+1, N);
printEven(I,N) ->
    done.