Erlang语法基础 #

-module(comments).
-export([func/1]).

func(X) ->
    X + 1.

-module(comment_style).
-export([process/1]).

process(Data) ->
    Result = transform(Data),
    Result.

transform(Data) ->
    Data.

-module(doc_comments).
-export([add/2]).

add(A, B) ->
    A + B.

-module(variables).
-export([demo/0]).

demo() ->
    Name = "Erlang",
    io:format("Hello, ~s~n", [Name]),
    _Unused = 42,
    ok.

ValidName = 1,
AnotherValid = 2,
_private = 3,
_Private = 4,

-module(atoms).
-export([demo/0]).

demo() ->
    ok,
    error,
    'Hello World',
    'with-hyphen',
    'with space',
    ok.

ok,
error,
undefined,
'Bad Request',
'Content-Type',

-module(my_module).
-module('MyModule').

func() -> ok.
my_function() -> ok.

-module(keywords).
-export([demo/1]).

demo(X) ->
    case X of
        0 -> zero;
        N when N > 0 -> positive;
        _ -> negative
    end.

-module(arithmetic).
-export([demo/0]).

demo() ->
    A = 10 + 5,
    B = 10 - 5,
    C = 10 * 5,
    D = 10 / 5,
    E = 10 div 3,
    F = 10 rem 3,
    io:format("~p ~p ~p ~p ~p ~p~n", [A, B, C, D, E, F]).

-module(comparison).
-export([demo/0]).

demo() ->
    true = 1 == 1,
    false = 1 == 2,
    true = 1 /= 2,
    true = 1 < 2,
    true = 1 =< 2,
    true = 2 > 1,
    true = 2 >= 1,
    true = 1 =:= 1,
    false = 1 =:= 1.0,
    false = 1 =/= 1,
    true = 1 =/= 1.0,
    ok.

-module(logical).
-export([demo/0]).

demo() ->
    true = true and true,
    false = true and false,
    true = true or false,
    false = false or false,
    false = not true,
    true = true xor false,
    true = true andalso true,
    true = true orelse false,
    ok.

-module(bitwise).
-export([demo/0]).

demo() ->
    16#0F = 16#FF band 16#0F,
    16#FF = 16#F0 bor 16#0F,
    16#F0 = 16#FF bxor 16#0F,
    16#F0 = bnot 16#0F,
    16#F0 = 16#0F bsl 4,
    16#0F = 16#F0 bsr 4,
    ok.

-module(list_ops).
-export([demo/0]).

demo() ->
    [1, 2, 3, 4, 5] = [1, 2, 3] ++ [4, 5],
    [1, 2, 3] = [1, 2, 3, 4, 5] -- [4, 5],
    [H | T] = [1, 2, 3],
    1 = H,
    [2, 3] = T,
    ok.

-module(block_expr).
-export([demo/0]).

demo() ->
    Result = begin
        A = 1,
        B = 2,
        A + B
    end,
    Result.

-module(if_expr).
-export([classify/1]).

classify(N) ->
    if
        N > 0 -> positive;
        N < 0 -> negative;
        true -> zero
    end.

-module(case_expr).
-export([classify/1]).

classify({point, X, Y}) ->
    if
        X > 0, Y > 0 -> first_quadrant;
        X < 0, Y > 0 -> second_quadrant;
        X < 0, Y < 0 -> third_quadrant;
        X > 0, Y < 0 -> fourth_quadrant;
        true -> on_axis
    end.

-module(fun_expr).
-export([demo/0]).

demo() ->
    Add = fun(A, B) -> A + B end,
    3 = Add(1, 2),
    Double = fun(X) -> X * 2 end,
    4 = Double(2),
    ok.

-module(pattern_match).
-export([demo/0]).

demo() ->
    {A, B} = {1, 2},
    [H | T] = [1, 2, 3],
    {point, X, Y} = {point, 10, 20},
    io:format("A=~p, B=~p~n", [A, B]),
    io:format("H=~p, T=~p~n", [H, T]),
    io:format("X=~p, Y=~p~n", [X, Y]),
    ok.

-module(match_operator).
-export([demo/0]).

demo() ->
    {ok, Value} = {ok, 42},
    42 = Value,
    ok.

-module(ignore_match).
-export([first/1, second/1]).

first({_, B}) -> B.
second({A, _}) -> A.

-module(guards).
-export([classify/1, max/2, valid_age/1]).

classify(N) when N > 0 -> positive;
classify(N) when N < 0 -> negative;
classify(0) -> zero.

max(A, B) when A > B -> A;
max(_, B) -> B.

valid_age(Age) when Age >= 0, Age =< 150 -> true;
valid_age(_) -> false.

-module(guard_seq).
-export([demo/1]).

demo(N) when N > 0, N < 10 -> small;
demo(N) when N >= 10, N < 100 -> medium;
demo(N) when N >= 100 -> large.

-module(guard_funcs).
-export([demo/1]).

demo(X) when is_integer(X) -> integer;
demo(X) when is_float(X) -> float;
demo(X) when is_list(X) -> list;
demo(X) when is_tuple(X) -> tuple;
demo(_) -> other.

-module(naming_conventions).

-export([public_function/1]).

-define(CONSTANT, 42).
-define(MACRO(X), X + 1).

-record(user, {id, name, email}).

public_function(VariableName) ->
    _UnusedVariable = 1,
    LocalVariable = 2,
    LocalVariable.

private_function(_Arg) ->
    ok.

-module(indent_style).
-export([process/1]).

process({type_a, Data}) ->
    Result = transform_a(Data),
    {ok, Result};
process({type_b, Data}) ->
    Result = transform_b(Data),
    {ok, Result};
process(Other) ->
    {error, {unknown_type, Other}}.

transform_a(Data) ->
    case Data of
        {value, V} -> V * 2;
        _ -> 0
    end.

transform_b(Data) ->
    if
        Data > 0 -> Data;
        true -> 0
    end.

long_function(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) ->
    Result = some_long_calculation(
        Arg1,
        Arg2,
        Arg3,
        Arg4,
        Arg5,
        Arg6
    ),
    Result.

function_clause(Pattern1) ->
    Body1;
function_clause(Pattern2) ->
    Body2;
function_clause(Pattern3) ->
    Body3.