OE>частично исправлено — IE отображает лямбды правильно, а вот FireFox не хочет

<span style="font-family: Symbol;">l</span>

λ

Параллелизм

Горячая замена кода

Функции высшего порядка

struct op_t
{
    virtual int operator()(int a, int b) = 0;
};

struct op_add : public op_t
{
    virtual int operator()(int a, int b)
    {
        return a + b;
    }
};

void show(int a, int b, op_t & op)
{
    printf("%d\n", op(a, b));
}

int main(int argc, char* argv[])
{
    op_add add;

    show(4, 5, add);

    return 0;
}

...Мы вынуждены создать два новых типа просто для поддержки различного клиентского кода!...

Карринг

#define square(x) pow((x), 2)

Ленивые вычисления

Абстрагирование от управляющих структур

Бесконечные структуры данных

Продолжения

Сопоставление с образцом

Замыкания

Function makePowerFn(int power)
{
   int powerFn(int base)
   {
     return pow(base, power);
   }

   return powerFn;
}

Function square = makePowerFn(2);
square(3); // возвращает 9

public interface CSDescriptor extends Serializable {
    /**
     *  @return descriptor type
     */
    String getDescriptorType();
}

public interface CSDescriptor extends Serializable {
    /**
     *  @return descriptor type
     */
    String getDescriptorType(Object param);
}

struct op_t
PVA>{
PVA>    virtual int operator()(int a, int b) = 0;
PVA>};

PVA>struct op_add : public op_t
PVA>{
PVA>    virtual int operator()(int a, int b)
PVA>    {
PVA>        return a + b;
PVA>    }
PVA>};

PVA>void show(int a, int b, op_t & op)
PVA>{
PVA>    printf("%d\n", op(a, b));
PVA>}

PVA>int main(int argc, char* argv[])
PVA>{
PVA>    op_add add;

PVA>    show(4, 5, add);

PVA>    return 0;
PVA>}

#define square(x) pow((x), 2)

Function makePowerFn(int power)
PVA>{
PVA>   int powerFn(int base)
PVA>   {
PVA>     return pow(base, power);
PVA>   }

PVA>   return powerFn;
PVA>}

PVA>Function square = makePowerFn(2);
PVA>square(3); // возвращает 9

let compose f g x = f(g x) ;;
let rec iterate n f =
    if n = 0 then (function x -> x)
    else compose f (iterate (n-1) f) ;;

(* использовать можно так *)
let rec power i n =
    let i_times = ( * ) i in  (* "i_times n" равно функции "умножить на i" n раз *)
        iterate n i_times 1 ;;

power 2 8 ;; (* выдаст 256 *)

LCR>let compose f g x = f(g x) ;;
LCR>let rec iterate n f =
LCR>    if n = 0 then (function x -> x)
LCR>    else compose f (iterate (n-1) f) ;;

LCR>(* использовать можно так *)
LCR>let rec power i n =
LCR>    let i_times = ( * ) i in  (* "i_times n" равно функции "умножить на i" n раз *)
LCR>        iterate n i_times 1 ;;

LCR>power 2 8 ;; (* выдаст 256 *)

let iterate n f (* x *) =
    let rec iter m x =
        if m=0 then x
        else f (iter (m-1))
    in iter n (* x *)
    ;;

(*******************************)

let iterate n f (* x *) =
    let rec iter m x =
        if m=0 then x
        else iter (m-1) (f x)
    in iter n (* x *)
    ;;

template<class F>
class iterate_n_f
{
    int n;
    F f;
public:
    iterate_n_f(int n, F f) : n(n), f(f) {}
    template<class X> X operator()(X x) const { for(int i=0; i!=n; ++i) x = f(x); return x; }
};
// карринг сделайте сами

Горячая замена кода

LCR>Компилируем. Меняем все зависимые от этого интерфейса классы. Компилируем. Дальше выгружаем все объекты этих классов, а также всех зависимых классов, а также всех зависимых от этих классов и т.п. на диск, пишем кастомный загрузчик (который обработает нестыковки), загружаем... Ещё что-то нужно делать со старыми потоками, а также старыми ресурсами (например, сокетами, коннекшнами к БД). Всё это контролировать настолько тяжело, что больше напоминает закат солнечной системы вручную, причём практически не отличается от перезапуска. Ну и девять девяток при таком подходе уж точно не видать...

LCR>Мне бы op_t принимающую любое количество параметров любого типа... Причём вместо создания экземпляра типа op_add я хочу просто писать (+).

Карринг

#define square(x) pow((x), 2)

Ленивые вычисления

Абстрагирование от управляющих структур

LCR>Возможно у вас есть свежая идея. Поделитесь?

Бесконечные структуры данных

LCR>Возможно у вас есть ещё одна свежая идея. Мне будет очень интересно.

Продолжения

Сопоставление с образцом

LCR>let compose f g x = f(g x) ;;
LCR>let rec iterate n f =
LCR>    if n = 0 then (function x -> x)
LCR>    else compose f (iterate (n-1) f) ;;

LCR>(* использовать можно так *)
LCR>let rec power i n =
LCR>    let i_times = ( * ) i in  (* "i_times n" равно функции "умножить на i" n раз *)
LCR>        iterate n i_times 1 ;;

LCR>power 2 8 ;; (* выдаст 256 *)
LCR>

An even more impressive instance of remote debugging occurred on NASA’s 1998 Deep Space 1 mission. A half year after the space craft launched, a bit of Lisp code was going to control the spacecraft for two days while conducting a sequence of experiments. Unfortunately, a subtle race condition in the code had escaped detection during ground testing and was already in space. When the bug manifested in the wild—100 million miles away from Earth—the team was able to diagnose and fix the running code, allowing the experiments to complete.

LCR>>Возможно у вас есть свежая идея. Поделитесь?

PVA>Не будем связываться . А что такое rt.jar?

LCR>>power 2 8 ;; (* выдаст 256 *)
LCR>>

PVA>(2 << 8) или power(2, 8), шутка

FR>Динамический типизированный не функциональный язык (например clisp ) подходит для этого не хуже.

public static Result preved(Object[] params, public Class[] types);
public static Result medved(Object[] params, public Class[] types);

public class Result
{
    public Object[] params;
    public Class[] types;
}

Функциональная программа уже готова для исполнения в параллельном режиме без дополнительных модификаций. Вам не нужно беспокоиться о взаимоблокировках (deadlocks) и борьбе за ресурсы (race conditions), потому что вам просто не потребуется использовать примитивы синхронизации (locks).

Пример на Эрланге можно глянуть здесь (там парни корёжат программу во время установленного телефонного звонка)

К>template<class F>
К>class iterate_n_f
К>{
К>    int n;
К>    F f;
К>public:
К>    iterate_n_f(int n, F f) : n(n), f(f) {}
К>    template<class X> X operator()(X x) const { for(int i=0; i!=n; ++i) x = f(x); return x; }
К>};
К>// карринг сделайте сами
К>

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

-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>Так что из ФЯ я для себя вынес только стойкую привязанность к ФВП и сопоставлению с образцом

M> А ленивость я только в Хаскеле и видел. Идея интересная, но на практике не понятно, как применяемая (для меня непонятная, естессно).

primes = sieve [2 .. ]   
sieve (x:xs) = x : sieve [y | y <- xs, (y `rem` x) /= 0]

take 10 primes 
-- вернёт [2,3,5,7,11,13,17,19,23,29]

fib = 1:1:(list_merge (+) fib (tail fib))

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

  template<typename Function> // function type R (T1, T2, ..., TN),
  class function 
    : public unary_function<R, T1> // iff N == 1
    : public binary_function<R, T1, T2> // iff N == 2
  {
  public:
    typedef R result_type;
        ...
    R operator()(T1, T2, ..., TN) const;
  };

// C++
void do_smth(PolymorficBaseType& p)
{
    // какой тип имеет объект р?

    SomeType s("Вася", 33); // догадается без SomeType ?

    unsigned int q = 3; // догадается без unsigned int ?
}

D>>// C++
D>>void do_smth(PolymorficBaseType& p)
D>>{
D>>    // какой тип имеет объект р?

D>>    SomeType s("Вася", 33); // догадается без SomeType ? // А что мешает догадаться? Вот чисто теоретически

D>>    unsigned int q = 3; // догадается без unsigned int ? // Аналогично
D>>}
D>>

// auto предлагается в C++0x использовать для указания того, что тип выводится автоматически
// ниже, конечно, псевдо-С++: 
auto foo()
{
    auto q(7, 22.3); 
    return q;
}

D>// C++
D>void do_smth(PolymorficBaseType& p)
D>{
D>    // какой тип имеет объект р?

D>    SomeType s("Вася", 33); // догадается без SomeType ?

D>    unsigned int q = 3; // догадается без unsigned int ?
D>}
D>

def do_smth(p)
{
  def s("Вася", 33)
  def q = 3;
}

D>(и это не только из-за фич С++ ).

D>>Давай вместе на них набросимся .

VD>... Чущь это...
VD>... Это тоже ахинея.

• или превращать эту ветку в очередной отстойник (а ля "ФП vs ООП"),
  
• или стерпеть эти выпады, зная что:
  
  1. читатель разумен и фильтрует любые сообщения, в т.ч. и это
     
  2. RSDN — это далеко неединственный источник информации

VD>def do_smth(p)
VD>{
VD>  def s("Вася", 33)
VD>  def q = 3;
VD>}

using Nemerle.Collections
module Main
    foo(bar : ref int) : void
        bar++
    Main() : void
        mutable x
        // Nemerle.Collections.Hashtable это дженерик тип с двумя параметрами
        def y = Hashtable()
        // здесь мы еще не знаем ни тип x, ни точный тип y
        x = y.GetValueOrDefault("somekey")
        // вот из этой строчки и будет выведен тип x
        foo(ref x)
        // напечатает 1
        System.Console.WriteLine(x)

module Main
    foo(_ : int) : void { }
    foo(_ : float) : void { }
    bar() : int { 1 }
    Main() : void
        // какой именно foo нам нужен?
        def f = foo
        // вот здесь компилятор это выяснит
        f(bar())
        // более сложный случай
        def foobar = (f,b) => f(b())
        foobar(foo,bar)

def h = Hashtable();
h.Add("aaa", 1);

using System.Console;

mutable var = 0;

def getCerrentState() { var }
def setCerrentState(newVal) { var = newVal }
def printIt(f) { WriteLine(f()); }

printIt(getCerrentState);
setCerrentState(getCerrentState() + 1);
printIt(getCerrentState);

0
1

interface ISomeInterface<T>
{
    void DoSmth(T val);
}

    // (a -> m b) 
    public delegate IMonad<B> BindDelegate<A,B>(A a);
    
    public interface IMonad<A>
    {
        // return :: a -> m a
        IMonad<A> ret(A val);
        // bind, >>= :: m a -> (a -> m b) -> m b
        IMonad<B> bind<B>(IMonad<A> ma,BindDelegate<A,B> binder);
    }

    public  class  Maybe<A> : IMonad<A>
    {
        #region IMonad<A> Members

        public IMonad<A> ret(A val)
        {
            return new Just<A>(val);
        }

        public IMonad<B> bind<B>(IMonad<A> ma, BindDelegate<A,B> binder)
        {
            if (ma is Just<A>)
                return binder((A)(ma as Just<A>).Val);

            return new Nothing<B>();
        }

        #endregion
    }
    public class Nothing<A> : Maybe<A>
    {
        public Nothing()
        { 
        
        }
    }
    public class Just<A> : Maybe<A>
    {
        public readonly object Val;
        public Just(A val)
        {
            Val = val;
        }
    }

firstElement :: [a] -> Maybe a
firstElement [] = Nothing
firstElement (x:xs) = Just x

        static Maybe<A> firstElement<A>(List<A> list)
        {
            if (list.Count == 0)
                return new Nothing<A>();
            return new Just<A>(list[0]);
        }

    List<int> empty = new List<int>();
    // выведет SharpMonads.Nothing`1[System.Int32]
    
    Console.WriteLine(firstElement<int>(empty).ToString());
    empty.Add(42);
    
    // выведет SharpMonads.Just`1[System.Int32]
    Console.WriteLine(firstElement<int>(empty).ToString());

Так что разумно говорить, что ФП — это программирование в выражениях которое стимулирует программирование без побочных эффектов. Причем именно ФП, а не ФЯ!

Есть одно четкое свойство выделяющее ФЯ — запись программы в виде выражений (expressions), а не statements.

L>Это я к твоей фразе о том, что "ФП — это отсутствие побочных эффетов — ахинея". ФП, конечно, это не отсутсвие сайд эффектов, но отсутствие сайд эффектов — отличительная черта ФП.

Конечно же отличительной чертой это не является, так как большая часть ФЯ позволяют менять переменные, и немало ИЯ имеют синтаксис для создания неизменяемых переменных. Если сказать, что это отилчительная черта, то С++ — это ФЯ.

Results Calculator( )
{
    Results results = null;

    while( true )
    {
        Input input = AskUser( results );
        if( input == null )
            break;
        else    
            results = DoMath( input, results ); // или DoMath(input) если программа не использует предыдущие вычисления
    }
    
    return results;
}

Calculator() : Results
{
    def AskFunc(results)
    {
        ( AskUser( results ), results )
    }

    def Calc(input,results)
    {
        if(input == null)
            results
        else
            Calc( AskFunc( DoMath( input, results ) ) )    // или DoMath(input) если программа не использует предыдущие вычисления
    }

    Calc( AskFunc(null) )
}

АХ>>Что такое пользователь? Это на самом деле функция AskUser( results ) которой даешь результаты, а она возвращает то что он ввел.

user(Timestamp) -> ...

NewWorld = io_fun(OldWorld).

АХ>>Что такое пользователь? Это на самом деле функция AskUser( results ) которой даешь результаты, а она возвращает то что он ввел.

Purely functional is a term in computing used to describe algorithms, data structures or programming languages that exclude destructive modifications (updates).

In computer science, a function is said to produce a side effect if it modifies some state other than its return value.

%%% язык типа эрланг, но аннотации типов из хаскеля.
append_char :: (File, Char) -> File.
append_char (File, Char) ->
  (use io api...).

main :: File -> (File, File).
main (file) ->
  {append_char(file, 'a'), append_char(file, 'b')}.

append_char :: (UNQ File, Char) -> UNQ File.
append_char (File, Char) ->
  (use io api...).

main :: UNQ File -> (UNQ File, UNQ File).
main(file) ->
  {append_char(file, 'a'), append_char(file, 'b')}.

main :: UNQ File -> (File, File).