%% 匹配成功：左侧模式匹配右侧值
X = 42.                %% X 绑定为 42
{A, B} = {1, 2}.       %% A=1, B=2
[H|T] = [1,2,3].       %% H=1, T=[2,3]

%% 匹配失败：抛出 badmatch 异常
X = 43.
%% ** exception error: no match of right hand side value 43

%% 两边都已绑定时，检查是否相等
X = 42.   %% ok（X 已经是 42）

%% 模式匹配可以解构任意复杂的数据
#{name := Name, age := Age} = #{name => "Alice", age => 25}.
%% Name="Alice", Age=25

%% area/1 的多个子句
area({circle, R}) ->
    math:pi() * R * R;
area({rect, W, H}) ->
    W * H;
area({triangle, B, H}) ->
    B * H / 2.

1> area({circle, 5}).
78.53981633974483
2> area({rect, 4, 6}).
24
3> area({triangle, 3, 8}).
12.0
4> area({square, 4}).
** exception error: no function clause matching area({square,4})

%% 子句顺序很重要！
classify(X) when is_number(X), X > 0 -> positive;
classify(X) when is_number(X), X < 0 -> negative;
classify(0) -> zero;
classify(_) -> not_a_number.

%% 解构元组参数
handle({connect, Host, Port}) ->
    io:format("Connecting to ~s:~p~n", [Host, Port]);
handle({disconnect, Reason}) ->
    io:format("Disconnected: ~p~n", [Reason]);
handle({data, Data}) ->
    io:format("Received: ~p~n", [Data]).

%% 解构列表参数
process([]) ->
    empty;
process([Single]) ->
    {one_element, Single};
process([First, Second]) ->
    {two_elements, First, Second};
process([H|T]) ->
    {head, H, tail_length, length(T)}.

%% 解构嵌套结构
process_message({chat, #{from := From, to := To, body := Body}}) ->
    io:format("~s -> ~s: ~s~n", [From, To, Body]);
process_message({system, Level, Msg}) ->
    io:format("[~p] ~s~n", [Level, Msg]).

%% when 关键字引入守卫
is_positive(X) when X > 0 -> true;
is_positive(_) -> false.

%% 多条件守卫（逗号 = 且）
in_range(X, Min, Max) when is_number(X), X >= Min, X =< Max ->
    true;
in_range(_, _, _) ->
    false.

%% 分号 = 或
is_adult({person, _, Age}) when Age >= 18; Age < 0 ->
    true;
is_adult(_) ->
    false.

%% ❌ 错误：守卫中不能调用自定义函数
is_valid(X) when my_module:check(X) -> true.

%% ✅ 正确：在函数体内调用
handle(X) ->
    case my_module:check(X) of
        true -> do_something(X);
        false -> error
    end.

%% 守卫中不能使用 and/or，使用逗号和分号代替
%% ❌ when X > 0 and X < 10
%% ✅ when X > 0, X < 10

%% =:= 严格相等（推荐）
1 =:= 1.0.    %% false
1 == 1.0.     %% true（类型转换）

%% 最佳实践：始终使用 =:= 和 =/=
%% 避免类型转换带来的隐式行为

%% case 语法
describe(Number) ->
    case Number of
        0 -> "zero";
        1 -> "one";
        2 -> "two";
        _ -> "many"
    end.

%% case 可以匹配任意模式
process(Result) ->
    case Result of
        {ok, Data} ->
            io:format("Success: ~p~n", [Data]);
        {error, Reason} ->
            io:format("Error: ~p~n", [Reason]);
        timeout ->
            io:format("Operation timed out~n")
    end.

classify_temperature(Temp) ->
    case Temp of
        T when T < 0 -> freezing;
        T when T < 15 -> cold;
        T when T < 25 -> comfortable;
        T when T < 35 -> warm;
        _ -> hot
    end.

%% ❌ 错误：不同分支绑定不同变量
case X of
    {a, Y} -> Y;       %% 绑定 Y
    {b, Z} -> Z         %% 绑定 Z（Y 未绑定）
end.
%% 编译错误：unsafe variable 'Y'

%% ✅ 正确：在 case 前预绑定
Y = undefined,
Z = undefined,
case X of
    {a, Y} -> Y;
    {b, Z} -> Z
end.

%% ✅ 更好的方式：使用嵌套函数或明确赋值
handle(X) ->
    Result = case X of
        {a, Val} -> Val;
        {b, Val} -> Val
    end,
    Result.

%% if 表达式（类似其他语言的 if-else）
abs_value(X) ->
    if
        X >= 0 -> X;
        true   -> -X     %% true 是"默认分支"（相当于 else）
    end.

%% 多条件
grade(Score) ->
    if
        Score >= 90 -> 'A';
        Score >= 80 -> 'B';
        Score >= 70 -> 'C';
        Score >= 60 -> 'D';
        true        -> 'F'
    end.

%% if 的每个分支都是守卫条件
check(X) ->
    if
        is_atom(X)    -> "atom";
        is_integer(X) -> "integer";
        is_list(X)    -> "list";
        true          -> "unknown"
    end.

%% 求列表长度（递归）
my_length([]) -> 0;
my_length([_H|T]) -> 1 + my_length(T).

%% 列表求和
sum([]) -> 0;
sum([H|T]) -> H + sum(T).

%% 列表反转
reverse([]) -> [];
reverse([H|T]) -> reverse(T) ++ [H].
%% 注意：这种写法效率低（O(n²)），实际使用 lists:reverse/1

%% 过滤偶数
filter_even([]) -> [];
filter_even([H|T]) when H rem 2 =:= 0 ->
    [H | filter_even(T)];
filter_even([_H|T]) ->
    filter_even(T).

%% 通用过滤器
filter(_Pred, []) -> [];
filter(Pred, [H|T]) ->
    case Pred(H) of
        true  -> [H | filter(Pred, T)];
        false -> filter(Pred, T)
    end.

%% 使用
1> filter(fun(X) -> X > 3 end, [1,2,3,4,5]).
[4,5]

%% 递归处理树结构
-type tree() :: {node, tree(), tree()} | {leaf, term()}.

sum_tree({leaf, Value}) ->
    Value;
sum_tree({node, Left, Right}) ->
    sum_tree(Left) + sum_tree(Right).

%% 使用
1> Tree = {node, {leaf, 1}, {node, {leaf, 2}, {leaf, 3}}}.
2> sum_tree(Tree).
6

%% 同时匹配多层结构
handle_event({click, {button, Id}, #{x := X, y := Y}}) ->
    io:format("Button ~p clicked at (~p, ~p)~n", [Id, X, Y]).

%% 匹配带默认值的 map
process(#{name := Name, age := Age, role := Role}) ->
    io:format("~s (~p): ~s~n", [Name, Age, Role]);
process(#{name := Name, age := Age}) ->
    process(#{name => Name, age => Age, role => "user"}).

%% 在模式中使用 = 绑定整个子结构
handle({person, _} = Person) ->
    %% Person 绑定了整个 {person, _} 元组
    process_person(Person).

%% 更复杂的例子
analyze([{tag, Tag} = Entry | Rest]) ->
    %% Entry 绑定整个 {tag, Tag} 元组
    io:format("Tag: ~p, Full entry: ~p~n", [Tag, Entry]),
    analyze(Rest);
analyze([]) ->
    ok.

%% 解析二进制协议
%% 格式: [版本:8][类型:8][长度:16][数据:binary]
parse_packet(<<Version:8, Type:8, Length:16, Data:Length/binary>>) ->
    {ok, #{version => Version, type => Type, data => Data}};
parse_packet(_) ->
    {error, invalid_packet}.

%% 解析 IPv4 地址
parse_ipv4(<<A:8, B:8, C:8, D:8>>) ->
    io_lib:format("~p.~p.~p.~p", [A, B, C, D]).

%% HTTP 状态行解析
parse_status_line(<<"HTTP/", Version:5/binary, " ", Code:3/binary, " ", Reason/binary>>) ->
    {Version, binary_to_integer(Code), binary_to_list(Reason)}.

%% Map 部分匹配（只匹配需要的 key）
greet(#{name := Name}) ->
    io:format("Hello, ~s!~n", [Name]).

%% 带守卫的 Map 匹配
check_access(#{role := admin}) ->
    full_access;
check_access(#{role := user, level := Level}) when Level >= 5 ->
    limited_access;
check_access(#{role := user}) ->
    read_only;
check_access(_) ->
    no_access.

%% 使用
1> greet(#{name => "Alice", age => 25}).
Hello, Alice!
ok
2> check_access(#{role => admin}).
full_access

%% command_parser.erl
-module(command_parser).
-export([parse/1, execute/1]).

-type command() ::
    {say, string()} |
    {move, atom()} |
    {attack, string()} |
    {look, string() | all} |
    quit.

-spec parse(string()) -> {ok, command()} | {error, string()}.
parse(Input) ->
    case string:lexemes(string:trim(Input), " ") of
        ["say" | Words] ->
            {ok, {say, string:join(Words, " ")}};
        ["move", Direction] ->
            case parse_direction(Direction) of
                {ok, Dir} -> {ok, {move, Dir}};
                error     -> {error, "Invalid direction: " ++ Direction}
            end;
        ["attack", Target] ->
            {ok, {attack, Target}};
        ["look"] ->
            {ok, {look, all}};
        ["look", Target] ->
            {ok, {look, Target}};
        ["quit"] ->
            {ok, quit};
        [] ->
            {error, "Empty command"};
        _ ->
            {error, "Unknown command"}
    end.

-spec execute(command()) -> string().
execute({say, Message}) ->
    "You say: " ++ Message;
execute({move, north}) -> "You move north. A dark corridor.";
execute({move, south}) -> "You move south. An open field.";
execute({move, east})  -> "You move east. A river blocks your path.";
execute({move, west})  -> "You move west. A mountain rises ahead.";
execute({attack, Target}) ->
    "You attack " ++ Target ++ "!";
execute({look, all}) ->
    "You see: a sword, a shield, and a potion.";
execute({look, Target}) ->
    "You examine: " ++ Target;
execute(quit) ->
    "Goodbye!".

-spec parse_direction(string()) -> {ok, atom()} | error.
parse_direction("north") -> {ok, north};
parse_direction("south") -> {ok, south};
parse_direction("east")  -> {ok, east};
parse_direction("west")  -> {ok, west};
parse_direction(_)       -> error.

$ erl
1> c(command_parser).
{ok, command_parser}
2> {ok, Cmd} = command_parser:parse("say hello world").
3> command_parser:execute(Cmd).
"You say: hello world"
4> {ok, Cmd2} = command_parser:parse("move north").
5> command_parser:execute(Cmd2).
"You move north. A dark corridor."

%% mini_json.erl
-module(mini_json).
-export([parse/1]).

%% 简化的 JSON 解析器（演示模式匹配）
parse(<<${, Rest/binary>>) ->
    parse_object(Rest, #{});
parse(<<$[, Rest/binary>>) ->
    parse_array(Rest, []);
parse(<<$", Rest/binary>>) ->
    parse_string(Rest, []).

parse_object(<<$}, Rest/binary>>, Acc) ->
    {Acc, Rest};
parse_object(<<$\s, Rest/binary>>, Acc) ->
    parse_object(Rest, Acc);
parse_object(<<$,, Rest/binary>>, Acc) ->
    parse_object(Rest, Acc);
parse_object(<<$", Rest/binary>>, Acc) ->
    {Key, Rest2} = parse_string(Rest, []),
    {Value, Rest3} = parse_value(skip_whitespace(Rest2)),
    parse_object(Rest3, Acc#{Key => Value}).

parse_array(<<$], Rest/binary>>, Acc) ->
    {lists:reverse(Acc), Rest};
parse_array(<<$\s, Rest/binary>>, Acc) ->
    parse_array(Rest, Acc);
parse_array(<<$, , Rest/binary>>, Acc) ->
    parse_array(Rest, Acc);
parse_array(Data, Acc) ->
    {Value, Rest} = parse_value(skip_whitespace(Data)),
    parse_array(Rest, [Value | Acc]).

parse_string(<<$", Rest/binary>>, Acc) ->
    {lists:reverse(Acc), Rest};
parse_string(<<C, Rest/binary>>, Acc) ->
    parse_string(Rest, [C | Acc]).

parse_value(<<$", Rest/binary>>) -> parse_string(Rest, []);
parse_value(<<${, Rest/binary>>) -> parse_object(Rest, #{});
parse_value(<<$[, Rest/binary>>) -> parse_array(Rest, []).

skip_whitespace(<<$\s, Rest/binary>>) -> skip_whitespace(Rest);
skip_whitespace(<<$\n, Rest/binary>>) -> skip_whitespace(Rest);
skip_whitespace(<<$\t, Rest/binary>>) -> skip_whitespace(Rest);
skip_whitespace(Data) -> Data.