Debugging 如何检查我的代码在Erlang中的什么地方卡住了？

我正在尝试编写一个函数，它接收一个列表，查找列表中的最大值整数，然后将列表中的所有其他整数除以该值

不幸的是，我的代码被卡住了。例如，如果这是python，我可以很容易地编写两个不同的“print”，看看它在哪里卡住了。但是在Erlang你是怎么做到的

这是代码

highest_value([], N) ->
    if
        N =:= 0 ->
            'Error! No positive values.'
    end,
    N;
highest_value([H|T], N) when H > N, H > 0 ->
    highest_value([T], H);
highest_value([_|T], N) ->
    highest_value([T], N).

divide(_L) -> [X / highest_value(_L, 0) || X <- _L].

最高_值（[]，N）->
如果
N=：=0->
“错！没有正值。”
完,，
N
当H>N，H>0->
最高_值（[T]，H）；
最高|值（[|T]，N）->
最高_值（[T]，N）。
除以（_L）->[X/最高的_值（_L，0）| | X，你可以直接使用。同样的事情

highest_value([H|T], N) when H > N, H > 0 -> 
   io:format(">>> when H bigger than N~n"),
   io:format(">>> H: ~p,  T: ~p, N: ~p ~n", [H, T, N]),
   highest_value([T], H);
highest_value(List) ->
   highest_value(List, 0).


编辑

有一件事你弄错了，那就是
[H | T]
语法。
H
或head是列表中的第一个元素。
T
代表tail，或“列表的其余部分”。顾名思义，tail是一个列表（可能是一个空列表，但仍然是一个列表）.因此，当您执行递归时，不需要将t放入新列表中

highest_value([H|T], N) when H > N -> 
     highest_value(T, H); 

highest_value([_|T], N) -> 
     highest_value(T, N).

在旧代码中，您调用了：

   highest_value([T], N).

它创建了一个包含一个元素的新列表，如
[[2,3,4,5]]
。如果您使用head-tail this，则只使用此元素列表作为head，使用空列表作为tail


另外，在第一个function子句中有一个atom
“Error！No positive values.”
（单引号表示这只是一个长的atom，而不是字符串），它永远不会返回（您将始终返回
N
）。如果要返回某个atom或
N
，根据
N
的值，您可以扩展函数子句的使用

highest_value([], 0) ->
   'Error! No positive values.'
highest_value([], N) ->
   N;
[...]

您必须使用
0
初始化函数，这可能被认为是一种错误的模式。您可以编写并使用
highest\u value/1
，它可以为您实现这一点

highest_value(List) ->
   highest_value(List, 0).

或者甚至可以使用此算法的修改：因为最大的数字将是列表中的一个数字，所以可以使用第一个元素作为函数初始化

highest_value(_List = [First|T]) when First > 0 ->
   highest_value(T, First).

这假设处理负数是您现在不关心的事情。
对于打印，您可以直接使用。同样的事情

highest_value([H|T], N) when H > N, H > 0 -> 
   io:format(">>> when H bigger than N~n"),
   io:format(">>> H: ~p,  T: ~p, N: ~p ~n", [H, T, N]),
   highest_value([T], H);
highest_value(List) ->
   highest_value(List, 0).


编辑

有一件事你弄错了，那就是
[H | T]
语法。
H
或head是列表中的第一个元素。
T
代表tail，或“列表的其余部分”。顾名思义，tail是一个列表（可能是一个空列表，但仍然是一个列表）.因此，当您执行递归时，不需要将t放入新列表中

highest_value([H|T], N) when H > N -> 
     highest_value(T, H); 

highest_value([_|T], N) -> 
     highest_value(T, N).

在旧代码中，您调用了：

   highest_value([T], N).

它创建了一个包含一个元素的新列表，如
[[2,3,4,5]]
。如果您使用head-tail this，则只使用此元素列表作为head，使用空列表作为tail


另外，在第一个function子句中有一个atom
“Error！No positive values.”
（单引号表示这只是一个长的atom，而不是字符串），它永远不会返回（您将始终返回
N
）。如果要返回某个atom或
N
，根据
N
的值，您可以扩展函数子句的使用

highest_value([], 0) ->
   'Error! No positive values.'
highest_value([], N) ->
   N;
[...]

您必须使用
0
初始化函数，这可能被认为是一种错误的模式。您可以编写并使用
highest\u value/1
，它可以为您实现这一点

highest_value(List) ->
   highest_value(List, 0).

或者甚至可以使用此算法的修改：因为最大的数字将是列表中的一个数字，所以可以使用第一个元素作为函数初始化

highest_value(_List = [First|T]) when First > 0 ->
   highest_value(T, First).

这假设处理负数是您现在不关心的事情。
对于打印，您可以直接使用。同样的事情

highest_value([H|T], N) when H > N, H > 0 -> 
   io:format(">>> when H bigger than N~n"),
   io:format(">>> H: ~p,  T: ~p, N: ~p ~n", [H, T, N]),
   highest_value([T], H);
highest_value(List) ->
   highest_value(List, 0).


编辑

有一件事你弄错了，那就是
[H | T]
语法。
H
或head是列表中的第一个元素。
T
代表tail，或“列表的其余部分”。顾名思义，tail是一个列表（可能是一个空列表，但仍然是一个列表）.因此，当您执行递归时，不需要将t放入新列表中

highest_value([H|T], N) when H > N -> 
     highest_value(T, H); 

highest_value([_|T], N) -> 
     highest_value(T, N).

在旧代码中，您调用了：

   highest_value([T], N).

它创建了一个包含一个元素的新列表，如
[[2,3,4,5]]
。如果您使用head-tail this，则只使用此元素列表作为head，使用空列表作为tail


另外，在第一个function子句中有一个atom
“Error！No positive values.”
（单引号表示这只是一个长的atom，而不是字符串），它永远不会返回（您将始终返回
N
）。如果要返回某个atom或
N
，根据
N
的值，您可以扩展函数子句的使用

highest_value([], 0) ->
   'Error! No positive values.'
highest_value([], N) ->
   N;
[...]

您必须使用
0
初始化函数，这可能被认为是一种错误的模式。您可以编写并使用
highest\u value/1
，它可以为您实现这一点

highest_value(List) ->
   highest_value(List, 0).

或者甚至可以使用此算法的修改：因为最大的数字将是列表中的一个数字，所以可以使用第一个元素作为函数初始化

highest_value(_List = [First|T]) when First > 0 ->
   highest_value(T, First).

这假设处理负数是您现在不关心的事情。
对于打印，您可以直接使用。同样的事情

highest_value([H|T], N) when H > N, H > 0 -> 
   io:format(">>> when H bigger than N~n"),
   io:format(">>> H: ~p,  T: ~p, N: ~p ~n", [H, T, N]),
   highest_value([T], H);
highest_value(List) ->
   highest_value(List, 0).


编辑

有一件事你弄错了，那就是
[H | T]
语法。
H
或head是列表中的第一个元素。
T
代表tail，或“列表的其余部分”。顾名思义，tail是一个列表（可能是一个空列表，但仍然是一个列表）.因此，当您执行递归时，不需要将t放入新列表中

highest_value([H|T], N) when H > N -> 
     highest_value(T, H); 

highest_value([_|T], N) -> 
     highest_value(T, N).

在旧代码中，您调用了：

   highest_value([T], N).

它创建了一个包含一个元素的新列表，如
[[2,3,4,5]]
。如果您使用head-tail this，则只使用此元素列表作为head，使用空列表作为tail


另外，在第一个function子句中有一个atom
错误