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

Debugging 如何检查我的代码在Erlang中的什么地方卡住了?,debugging,functional-programming,erlang,pattern-matching,Debugging,Functional Programming,Erlang,Pattern Matching,我正在尝试编写一个函数,它接收一个列表,查找列表中的最大值整数,然后将列表中的所有其他整数除以该值 不幸的是,我的代码被卡住了。例如,如果这是python,我可以很容易地编写两个不同的“print”,看看它在哪里卡住了。但是在Erlang你是怎么做到的 这是代码 highest_value([], N) -> if N =:= 0 -> 'Error! No positive values.' end, N; highe

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

不幸的是,我的代码被卡住了。例如,如果这是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
错误