Erlang初学者：找到外围吗？

Question

I am learning Erlang and was attempting problem mentioned here , as

3. Write a function mathStuff:perimeter(Form) which computes the perimeter of different forms. Form can be one of:

    {square,Side}
    {circle,Radius}
    {triangle,A,B,C}

So, my solution to this is

-module(mathStuff).
-export([perimeter/1]).

perimeter(Form) ->
        case element(1, Form) of
                square          -> io:format("perimeter for square is ~p~n", [4*element(2, Form)]);
                circle          -> io:format("perimeter for circle is ~p~n", [2*math:pi()*element(2, Form)]);
                triangle        -> io:format("perimeter for triangle ~p~n", [element(2, Form) + element(3, Form) + element(4, Form)])
        end.
~             

and when I run I get

38> c("mathStuff.erl").              
{ok,mathStuff}
39> mathStuff:perimeter({circle, 2}).
perimeter for circle is 12.566370614359172
ok
40> mathStuff:perimeter({rectangle, 2}).
** exception error: no case clause matching rectangle
     in function  mathStuff:perimeter/1 (mathStuff.erl, line 5)
41> mathStuff:perimeter({square, 2}).   
perimeter for square is 8
ok
42> mathStuff:perimeter({traingle, 1, 2, 3}).
** exception error: no case clause matching traingle
     in function  mathStuff:perimeter/1 (mathStuff.erl, line 5)
43> mathStuff:perimeter({triangle, 1, 2, 3}).
perimeter for triangle 6
ok

but this is incorrect since I can also do

44> mathStuff:perimeter({triangle, 1, 2, 3, 4}).
perimeter for triangle 6
ok
45> 

What is a better way to approach this problem, how can I be more specific about type and arguments?

Answer 1

The reason for the first error is that you are not matching rectangle in your case ... end expression, so it fails to match anything. Unlike most imperative languages, a case expression in a functional language is generally required to match at least one clause -- otherwise, what value should the expression evaluate to?

A more idiomatic way of solving this problem involves pattern matching at the function head, like so:

perimeter({square, Side}) ->
    io:format("perimeter for square is ~p~n", [4*Side]);
...
perimeter({triangle, A, B, C}) ->
    io:format("perimeter for triangle ~p~n", [A + B + C]).

Note that the function clauses are separated using ; , with the last clause being terminated with . .

In essence, instead of manually selecting fields from the tuple with element/2 , Erlang allows you to "unpack" the tuple using pattern matching. This is, in my opinion, one of the greatest benefits of using a functional language with algebraic data types.

Incidentally, the reason that you got a correct result even for an erroneous call like perimeter({triangle, 1, 2, 3, 4}) is that you didn't use pattern matching, but instead manually selected the relevant fields of the tuple. You never checked that the tuple wasn't too long! Pattern matching performs a kind of input validation as a side-effect, because an expression like:

{A, B, C} = {1, 2, 3, 4}

Is guaranteed to fail with a match error.