А я не шублю. Я тебе сказал свое мнение. ФЯ ужербны и недоработаны. В них есть рациональное зерно, но оно отнюдь не в ругательствах вроде "lazy evaluation, lazy data structures" (это скорее затычки проблем чем достоинства). (VladD2)

В статье много интересных идей... Но! Это типичная рекламная статья от евангелиста данной технологии. Послушать аплогогетов нейронных сетей или ИИ — так совершенно непонятно, почему до сих пор по улицам не ходят андроиды, а мы все не в матрице... Тут применяются обычные рекламные трюки — декларируемые, потенциальные возможности выдаются за действительные... (AndreyFedotov по поводу статьи Вадлера)

На самом деле их никто не использует только потому, что в RSDN Mag до сих пор нет ни одной статьи на их тему. Я уверен, что как только выйдет хорошая статья с практическим примером того, как современная популярная прикладная задача на раз-два-три решается на функциональном языке, прикладники потянутся в эту сторону. Грамотный маркетинг — основа успеха. (Sinclair)

Поскольку программное обеспечение постоянно усложняется, повышается и необходимость в улучшении его структуры. Хорошо структурированное программное обеспечение проще пишется и легче отлаживается, оно предоставляет набор многократно используемых модулей, уменьшает затраты на программирование в будущем. Традиционные языки имеют концептуальные ограничения на организацию модульной структуры. Функциональные языки снимают эти ограничения. В статье рассмотрено практическое использование двух особенностей функциональных языков, способствующих повышению модульности: функций более высокого порядка и ленивых вычислений. В качестве примеров используются списки и деревья, несколько численных алгоритмов, а также альфа-бета эвристика (алгоритм из области искусственного интеллекта, используемый в игровых программах). Так как модульность — ключ к успешному программированию, функциональные языки жизненно важны для реального мира.

Нашел перевод классической статьи Джона Хьюза. Сомневаюсь, что у меня получилось-бы лучше. Нет, это не Вадлер. Это Хьюз. Вот это — типичная (и самая известная) рекламная статья. С практическими примерами — как заказывали.

AF> Я обратил внимание на интересную особенность статей и примеров по ФЯ (в том числе и этого): они все иллюстрируют, как здорово можно реализовать тот или иной алгоритм, и рассуждают об общих принципах. Но как правильно отметил bleed — и я с ним полностью согласен — я ни разу не видел примера или хотя бы намёка — как на ФЯ построить систему и чем система (а не отдельный алгоритм) — будет лучше, почему её удобнее было бы строить на ФЯ или удобнее было бы развивать на ФЯ, чем на ИЯ.

В этой статье утверждается, что модульность — ключ к успешному программированию. Языки, которые стремятся улучшить производительность, должны поддерживать модульное программирование. Но новые правила видимости и механизмы раздельной трансляции недостаточны. Модульность — нечто большее, чем модули. Наша способность расчленять проблему на части зависит непосредственно от нашей способности склеить решения. Чтобы поддерживать модульное программирование, язык должен обеспечить хороший клей. Функциональные языки программирования обеспечивают два новых вида клея — функции высшего порядка и ленивые вычисления. При использовании этих клеев программы могут быть модуляризованы новыми и захватывающими способами, и мы дали много примеров этому. Маленькие и очень общие модули могут широко и многократно использоваться, облегчая последующее программирование. Это объясняет, почему функциональные программы намного меньше и почему их проще писать, чем обычные. Если какая то часть программы беспорядочна или сложна, программист должен попытаться разбить её на модули и обобщить части. Он должен попытаться использовать функции высшего порядка и ленивые вычисления как инструментальные средства для выполнения этой задачи.

AF> Но как быть, если алгоритмы просты, зато структура системы сложна (что бывает гораздо чаще — это бухгалтерские или ERP системы)?Есть большое подозрение — что здесь если и есть выигрышь у ФЯ языков (в чём я лично очень сомневаюсь) — то он минимален и просто не стоит того, что бы их применять.

AF> Хотя возможно, что я в этом ошибаюсь.

NewTree = insert( Element, Tree ),
do_something( NewTree, Tree );

A1 = change1( A ),
A2 = change2( A1 ),
A3 = change3( A2 ),
...

state_machine( state_A ) ->
   receive
      switch_to_state_C -> state_machine( state_C );
      switch_to_state_B -> state_machine( state_B )
   end;

state_machine( state_B ) ->
   receive
      switch_to_state_A -> state_machine( state_A );
      switch_to_state_C -> state_machine( state_C )
   end;

state_machine( state_C ) ->
   receive
      exit -> nil;
      switch_to_state_A -> state_machine( state_A )
   end.

switch_state( state_A, Message ) ->
   case Message of
      switch_to_state_C -> state_C;
      switch_to_state_B -> state_B
   end;

switch_state( state_B, Message ) ->
   case Message of
      switch_to_state_A -> state_A;
      switch_to_state_C -> state_C
   end;

switch_state( state_C, Message ) ->
   case Message of
      exit -> terminal_state;
      switch_to_state_A -> state_A
   end.

// специальный тип: либо какое-то значение либо ничего. Удобно применять подобный тип в случаях, когда
// функция может вернуть или значение или ошибку (или отказаться возвращать значение).
type 'a my_type = SOME of 'a | NONE;

// для создания функций для прямой
let create_line_func x (x1,y1) (x2,y2) =
    if (x1 = x2) then NONE else SOME (y1-y2)*(x-x1)/(x1-x2)+y1;

// Пересечение со стороной прямоугольника, y1 < y2
let check_intersect line_f (x, (y1, y2))
    match line_f x with
        SOME y => if ((y >= y1) and (y <= y2)) then (x,y) else nill
    |   NONE => nill;

let swap_points (x1,y1) (x2,y2) =
    if (x1 == x2)
        if (y1 > y2) then ((x2,y2),(x1,y1)) else ((x1,y1),(x2,y2))
    else if (x1 > x2) then ((x2,y2),(x1,y1) else ((x1,y1),(x2,y2));

// обрезаем отрезок p1 p2 по отрезку  x y 
adjust_result p1 p2 (x1,y1) (x2,y2) flag
    if (flag = 0) then SOME (p1,p2) else
    let (np1, np2) = swap_points p1 p2 in // упорядочиваем точки по возрастанию
    let (q1, q2) = swap_points (x1,y1) (x2,y2) in // ниже функция > для сравнения 2-х точек
    let greater = if (x1 = x2) then (function (x1,y1) (x2,y2) -> if (y1 > y2) then true else false)
                   else (function (x1,y1) (x2,y2) -> if (x1 > x2) then true else false) in
    // 5 случаев взимного расположения отрезков
    if (greater q1 np2) then NONE
    else if (greater np1 q1) then NONE
    else if ((greater q1 np1) and (greater np2 q2) then SOME (q1,q2)
    else SOME ((if (greater np1 q1) then np1 else q1), (if (greater (q2 np2) then np2 else q2));

// пересечение линии или отрезка с прямоугольником
let intersect_line ((x1,y1),(x2,y2)) ((a1,b1),(a2,b2)) flag =
    let line_f_h x = create_line_func x (x1,y1) (x2,y2) in //уравнение прямой относительно оси X
    let line_f_v y = create_line_func y (y1,x1) (y2,x2) in //уравнение прямой относительно оси Y
    let result = (check_intersect line_f_h (a1, (b1,b2))) :: (check_intersect line_f_h (a2, (b1,b2))) ::
                 (check_intersect line_f_v (b1, (a1,a2))) :: (check_intersect line_f_v (b2, (a1,a2))) :: 
                 nill in // здесь мы создали список точек пересечения прямой с прямоугольником
    match result with
        p1::p2::nill => SOME (adjust_result p1 p2 (x1,y1) (x2,y2) flag) // отрезок
    |   p1::nill => SOME (adjust_result p1 p1 (x1,y1) (x2,y2) flag)   // точка
    |   _ => NONE;                 // пустое множество

let order (a,b) = 
if (a +. b == nan) 
    then (neg_infinity, infinity) (* Это случай, когда прямая проходит точно по краю прямоугольника *)
    else (if (a<b) then (a,b) else (b,a))

let cut_1d vec1d cut = (cut -. fst vec1d) /. snd vec1d

let dual_cut_1d vec1d (cut1, cut2) = order ((cut_1d vec1d cut1), (cut_1d vec1d cut2))

let add_cuts (min1, max1) (min2, max2) = (max min1 min2, min max1 max2)

let cut_vec_rect vec rect part = List.fold_left add_cuts part (List.map2 dual_cut_1d vec rect) 

let actual_cut_points vec rect part = 
    let (cut1, cut2) = cut_vec_rect vec rect part in
    if (cut1 <= cut2) 
        then List.map (fun (p, d) -> ((p +. cut1 *. d), (p +. cut2 *. d))) vec
        else []

let linia = (neg_infinity, infinity)
let otrezok = (0., 1.)

let bypoints2bydimensions vec = List.fold_left2 (fun l c1 c2 -> (c1,c2)::l) [] (fst vec) (snd vec)
let bydimensions2bypoints vec = List.fold_left (fun (l1, l2) (c1, c2) -> (c1::l1, c2::l2)) ([], []) vec

let makevec vec = List.map (fun (c1, c2) -> (c1, c2 -. c1)) (bypoints2bydimensions vec)
let makerect = bypoints2bydimensions
let showvec = bydimensions2bypoints

let testvec = makevec ([0.; 0.] , [2.; 0.])  (* ([x1; y1] , [x2; y2]) *) 
let testrect = makerect ([0.; 0.] , [3.; 2.]) (* ([x1; y1] , [x2; y2]) *)

let r = showvec (actual_cut_points testvec testrect linia)

VD>В общем, я только укрепился во мнении, что ленивые вычисления — это средство склаживания проблем самого функционального подхода. В ИЯ я необходимости такого механизма не вижу.

  virtual string* Foo(){
    yield return "Hello world1";
    yield return "Hello world2";
    yield return "Hello world3";  }

public class Buffer {
   public async Put(string s);
   public string Get() & Put(string s) { return s; }
}

G>>Да... Тут еще про ядерный реактор пример приводили, типа конечный автомат на ФЯ невозможно сделать. Называется, не бросайте меня в терновый куст. Так вот, мне лично было бы спокойнее, если бы управляющая программа этого реактора целиком была написана на ФЯ, и корректность ключевых модулей была-бы доказана . Я уже насмотрелся на прелести программирования "с помощью эффекта" за последние 10 лет, достало. А как вам — не знаю.

main = do fromHandle <- getAndOpenFile "Copy from: " ReadMode
          toHandle   <- getAndOpenFile "Copy to: " WriteMode 
          contents   <- hGetContents fromHandle
          hPutStr toHandle contents
          hClose toHandle
          putStr "Done."

getAndOpenFile          :: String -> IOMode -> IO Handle

getAndOpenFile prompt mode =
    do putStr prompt
       name <- getLine
       catch (openFile name mode)
             (\_ -> do putStrLn ("Cannot open "++ name ++ "\n")
                       getAndOpenFile prompt mode)

Другой новый вид клея, который используют функциональные языки, допускает склеивать целые программы. Напомним, что функциональная программа — просто функция из входных данных в её выходные данные. Если F и G — такие программы, то (G . F) — программа которая, вычисляет G (F input). Программа F вычисляет свой вывод, который используется как ввод, для программы G. Традиционно,это можно осуществить, сохраняя вывод F во временный файл. Проблема состоит в том, что временный файл может занять так много памяти, что непрактично склеивать программы подобным образом.

B>  virtual string* Foo(){
B>    yield return "Hello world1";
B>    yield return "Hello world2";
B>    yield return "Hello world3";  }
B>

        /// <summary>
        /// Возвращает энумератор позволяющий перебрать элементы коллеции 
        /// в обратном порядке.
        /// </summary>
        public IEnumerator<T> GetReverseEnumerator()
        {
            for (int i = _len - 1; i >= 0; i--)
                yield return _ary[i];
        }

B>public class Buffer {
B>   public async Put(string s);
B>   public string Get() & Put(string s) { return s; }
B>} 
B>

delegate int D(int i1, int i2);

int X(D d, int i1, int i2)
{
    ...
}

G> Nemerle. Получите, если захотите взять

        /// <summary>
        /// Позволяет найти элемент.
        /// </summary>
        /// <param name="predicate">
        /// Предикат поиска (делегат возвращающий true если текущий 
        /// элемент удовлетворяет критериям поиска).</param>
        /// <returns>Искомый элемент.</returns>
        public T Find(Predicate<T> predicate)
        {
            for (int i = 0; i < _len; i++)
                if (predicate(_ary[i]))
                    return _ary[i];

            return default(T);
        }

        /// <summary>
        /// Позволяет найти индекс элемента. Перебор начинается с конца списка и 
        /// продолжается до нулевого элмента.
        /// </summary>
        /// <param name="predicate">
        /// Предикат поиска (делегат возвращающий true если текущий 
        /// элемент удовлетворяет критериям поиска).</param>
        /// <returns>Искомый элемент.</returns>
        public int FindLastIndex(Predicate<T> predicate)
        {
            for (int i = _len - 1; i >= 0; i--)
                if (predicate(_ary[i]))
                    return i;
            return -1;
        }

        /// <summary>
        /// Позволяет найти индекс элемента. Перебор начинается с конца списка и 
        /// продолжается до нулевого элмента.
        /// </summary>
        /// <param name="predicate">
        /// Предикат поиска (делегат возвращающий true если текущий 
        /// элемент удовлетворяет критериям поиска).</param>
        /// <returns>Искомый элемент.</returns>
        public int FindIndex(Predicate<T> predicate)
        {
            for (int i = 0; i < _len; i++)
                if (predicate(_ary[i]))
                    return i;

            return -1;
        }
        
        
        /// <summary>
        /// <para>Позволяет выполнить некоторое действие для каждого элемента.
        /// </para>
        /// <para>Перебор осуществляется в прямом порядке.</para>
        /// </summary>
        /// <param name="action">Делегат выполняемый для каждого элемента.</param>
        public void ForEeach(Action<T> action)
        {
            for (int i = 0; i < _len; i++)
                action(_ary[i]);
        }

public delegate void Action<T>(T obj);
public delegate bool Predicate<T>(T obj);

SomeCollection<int> list = SomeCollection<int>(new int[]{ 1, 3, 4, 6, 9 });
int sum = 0;
// Жирным выделен анонимный метод, т.е. метод обявляемый инлайном.
// Забавно так же что можно использовать переменную sum объявленную
// в том же методе где вызывается list.ForEeach.
list.ForEeach(delegate(int elem){ sum += elem; });
Console.WriteLine(sum);

// В принципе можно вместо делегата просто передать ссылку на метод
// реализованный где угодно.
Multiplier multiplier = new Multiplier();
list.ForEeach(multiplier.Multiply);
Console.WriteLine(multiplier.Result);

...

class Multiplier
{
    public int Result = 0;
    public void Multiply(int elem)
    {
        Result *= elem;
    }
}

    public interface IEnumerator<T> : System.IDisposable
    {
        T Current { get; }
        bool MoveNext();
    }