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 ;;