Funktionen und Mustervergleich

-export([main/1]).

fak(0) -> 1;
fak(N) when N > 0 -> N * fak(N - 1).

vorzeichen(N) when N > 0 -> positiv;
vorzeichen(N) when N < 0 -> negativ;
vorzeichen(0) -> null.

flaeche({kreis, R}) -> math:pi() * R * R;
flaeche({rechteck, B, H}) -> B * H;
flaeche({quadrat, S}) -> S * S.

begruesse(Name) -> begruesse(Name, "Hallo").
begruesse(Name, Gruss) -> Gruss ++ ", " ++ Name ++ "!".

main(_) ->
    io:format("~p~n", [fak(10)]),
    io:format("~p ~p ~p~n", [vorzeichen(5), vorzeichen(-2), vorzeichen(0)]),
    io:format("~.2f ~p ~p~n", [flaeche({kreis, 1}), flaeche({rechteck, 3, 4}), flaeche({quadrat, 5})]),
    io:format("~s~n", [begruesse("Mia")]),
    io:format("~s~n", [begruesse("Tom", "Servus")]).

3628800
positiv negativ null
3.14 12 25
Hallo, Mia!
Servus, Tom!

main(_) ->
    N = 15,
    Text = case {N rem 3, N rem 5} of
        {0, 0} -> "FizzBuzz";
        {0, _} -> "Fizz";
        {_, 0} -> "Buzz";
        _ -> integer_to_list(N)
    end,
    io:format("~s~n", [Text]),

    Gross = if N > 10 -> groß; true -> klein end,
    io:format("~p~n", [Gross]),

    Pruefe = fun(X) when is_integer(X), X > 0 -> positiv;
                (X) when is_integer(X) -> nicht_positiv;
                (_) -> kein_integer
             end,
    io:format("~p ~p ~p~n", [Pruefe(5), Pruefe(-1), Pruefe(a)]),

    io:format("~p~n", [case [1, 2, 3] of [_, Zweites | _] -> Zweites end]),
    io:format("~p~n", [(1 < 2) andalso (2 < 3)]),
    io:format("~p~n", [(1 > 2) orelse (2 < 3)]),
    io:format("~p~n", [not false]),
    io:format("~p~n", [1 =:= 1.0]),
    io:format("~p~n", [1 == 1.0]),
    io:format("~p~n", [1 =/= 2]).

FizzBuzz
gro�
positiv nicht_positiv kein_integer
2
true
true
true
false
true
true

main(_) ->
    Verdopple = fun(X) -> X * 2 end,
    Addiere = fun(A, B) -> A + B end,
    io:format("~p ~p~n", [Verdopple(21), Addiere(3, 4)]),

    Fak = fun F(0) -> 1; F(N) -> N * F(N - 1) end,
    io:format("~p~n", [Fak(10)]),

    Anwenden = fun(F, X) -> F(F(X)) end,
    io:format("~p~n", [Anwenden(Verdopple, 5)]),

    Addierer = fun(N) -> fun(X) -> X + N end end,
    Plus10 = Addierer(10),
    io:format("~p~n", [Plus10(5)]),

    io:format("~p~n", [lists:map(fun erlang:abs/1, [-1, 2, -3])]),
    io:format("~p~n", [lists:map(fun(X) -> X * X end, [1, 2, 3, 4])]),
    io:format("~p~n", [(fun lists:reverse/1)([1, 2, 3])]).

42 7
3628800
20
15
[1,2,3]
[1,4,9,16]
[3,2,1]