-module(hot).
-compile(export_all).

start() ->
    register(the_server, spawn(hot, server, [abcd])),
    register(the_client, spawn(hot, client, [0, the_server])).

stop() ->
    the_client ! stop,
    the_server ! stop.

client(N, Svr) ->
    receive
    stop ->
        io:format("client stopped~n", []),
        stop_client
    after 1000 ->
        Svr ! N,
        client(N + 1, Svr)
    end.

server(State) ->
    receive
    stop ->
        io:format("server stopped~n", []),
        stop_server;
    Msg ->
        io:format("Msg, State => ~p, ~p~n", [Msg, State]),
        hot:server(State)
    end.

server(State) when is_atom(State) ->
    server_plus(atom_to_list(State)).

server_plus(State) ->
    receive
    stop ->
        io:format("server stopped~n", []),
        stop_server;
    Msg ->
        io:format("Msg, State >>> ~p, ~p~n", [Msg, State]),
        hot:server_plus(State)
    end.

20> c(hot).           %%% компилируем и загружаем модуль hot
{ok,hot}
21> hot:start().      %%% запускаем функцию start в модуле hot
true
Msg, State => 0, abcd
Msg, State => 1, abcd
Msg, State => 2, abcd
Msg, State => 3, abcd
Msg, State => 4, abcd
22> c(hot).                %%% меняем функцию server
{ok,hot}
Msg, State => 5, abcd      %%% в этот момент новый код загружен
Msg, State >>> 6, "abcd"  %%% и управление передано на новую функцию server
Msg, State >>> 7, "abcd"
Msg, State >>> 8, "abcd"
Msg, State >>> 9, "abcd"
Msg, State >>> 10, "abcd"
Msg, State >>> 11, "abcd"
Msg, State >>> 12, "abcd"
Msg, State >>> 13, "abcd"
Msg, State >>> 14, "abcd"
Msg, State >>> 15, "abcd"
Msg, State >>> 16, "abcd"
Msg, State >>> 17, "abcd"
23> hot:stop().
client stopped
server stopped
stop
24>

LCR>Очень интересно. Но в данном случае ты взял заботу компилятора на себя и несмотря на то, что хорошо справился (), я не думаю что этот подход разумен в общем случае.

LCR>let mk_index list_names =
LCR>    let rec make_enum a b = if a > b then [] else a :: (make_enum (a+1) b) in
LCR>    let list_index = (make_enum 0 ((List.length list_names) - 1)) in
LCR>    let assoc_index_name = List.combine list_names list_index in
LCR>        function name -> List.assoc name assoc_index_name ;;

let make_enum a b =
    let rec fwd c cs = if c > b then [] else fwd (c+1) (c::cs)
    in
    List.reverse (fwd a [])
    ;;

let make_enum a b =
    let rec rew c cs = if c < a then [] else rew (c-1) (c::cs)
    in
    (rew b [])
    ;;

let mk_index list_names name =
    let bla-bla-bla
    in
    List.assoc name assoc_index_name
    ;;

tagStart(Tag) ->
    tagStart(Tag, []).
tagStart(Tag, Attrs) when Attrs == []->
        "<" ++ F ++ ">";
tagStart(Tag, Attrs)->
    "<" ++ F ++ " " ++ attributes(X) ++ ">".

attributes([{Key, Value}|L]) ->
    Key ++ "=\"" ++ Value ++ "\" " ++ attributes(L);
attributes([]) ->
    [].

attributes([{Key, Value}|L]) ->
    %% ...

tagStart("myTag", [
                    {"attr", "key"},
                    {"attr2", "key2"}
                  ])

<myTag attr="key" attr2="key2">

function some_func(X)
{
    return X*2;
}

function myFunc(args) /*args - массив данных*/
{
    arr = new Array;
    for(i = 0; i < args.length; i++)
    {
        arr.push(some_func(args[i]));
    }
    
    return arr;
}

function some_func(X)
{
    return X*2;
}

function map(Func, Arr)
{
    arr = new Array;
    
    for(i = 0; i < args.length; i++)
    {
        arr.push(Func(args[i]));
    }
    
    return arr;
}

function myFunc(args)
{
    return map(some_func, args);
}

map(Func, []) -> [];
map(Func, [Head|Tail]) -> Func(Head) ++ map(Func, Tail).

M>Но на самом деле... Хм. Например, вот код, генерирующий xml тэг со всеми аттрибутами (на Эрланге, естессно ):

M>tagStart(Tag) ->
M>    tagStart(Tag, []).
M>tagStart(Tag, Attrs) when Attrs == []->
M>        "<" ++ F ++ ">";
M>tagStart(Tag, Attrs)->
M>    "<" ++ F ++ " " ++ attributes(X) ++ ">".

M>attributes([{Key, Value}|L]) ->
M>    Key ++ "=\"" ++ Value ++ "\" " ++ attributes(L);
M>attributes([]) ->
M>    [].
M>

using System.Console;

def tagStart(tag, attrs = [])
{
  | (tag, [])    => $"<$tag>"
  | (tag, attrs) => $"<$tag$(attributes(attrs))>"
}
and attributes(attrs)
{
  | (key, value) :: tail => $" $key='$value'$(attributes(tail))"
  | []                   => ""
} 

WriteLine(tagStart("SimpleTeg"));
WriteLine(tagStart("TegWithAttributes", [("attr", "key"), ("attr2", "key2")]));

<SimpleTeg>
<TegWithAttributes attr='key' attr2='key2'>

M>attributes([{Key, Value}|L]) ->
M>    %% ...
M>

M>я готов продать душу любому языку программирования

M>>>Но на самом деле... Хм. Например, вот код, генерирующий xml тэг со всеми аттрибутами (на Эрланге, естессно ):

M>>>tagStart(Tag) ->
M>>>    tagStart(Tag, []).
M>>>tagStart(Tag, Attrs) when Attrs == []->
M>>>        "<" ++ F ++ ">";
M>>>tagStart(Tag, Attrs)->
M>>>    "<" ++ F ++ " " ++ attributes(X) ++ ">".

M>>>attributes([{Key, Value}|L]) ->
M>>>    Key ++ "=\"" ++ Value ++ "\" " ++ attributes(L);
M>>>attributes([]) ->
M>>>    [].
M>>>

VD>>Вот только данный пример на http://www.stringtemplate.org/ выглядит несколько лучше.

M>Где? А то я смотрю в книгу и вижу известно что

tagStart(tag, attrs) ::= <$tag$ $attrs:{ key, val | $key$="$val$" }; separator=", "$>

M>Ну, не приводить же сразу какой-нибудь ErlyDB

VD>>Да! И что на счет таких "неотемлемых приемуществ ФЯ" как каринг и ленивость?

M>В каринг я пока не въехал, поэтому говорить о нем ничего не буду А ленивость я только в Хаскеле и видел. Идея интересная, но на практике не понятно, как применяемая (для меня непонятная, естессно).

M>Так что из ФЯ я для себя вынес только стойкую привязанность к ФВП и сопоставлению с образцом