Мне удалось раздобыть выкинутую кем-то книгу по Лиспу, написанную в 1982 году Уинстоном и Хорном (Winston and Horn). Что приводит меня в изумление — это те типы проблем, которые решались в конце 70-х. Из оглавения [1]:
18: Lisp in Lisp (Building an interpreter)
24: Symbolic pattern matching
26: Rule based expert systems and forward chaining
30: Procedure writing programs

...
Что меня волнует, так это то, что "старые" языки могли выполнять задачи, которые (как мне кажется) сложны или вообще невыполнимы в современных языках. Как так произошло, что все эти Java и C# потеряли все эти возможности, а называются "современными"?

CHAPTER 9 Introducing Language-Oriented Programming
CHAPTER 12 Working with Symbolic Representations
CHAPTER 13 Reactive, Asynchronous, and Concurrent Programming
CHAPTER 16 Lexing and Parsing

html |> getWords |> List.filter (fun s -> s = "href")

List.filter(s=> s == "href", getWords(html))

let (|>) x f = f x

// тут сумма не вычислится
let sum = lazy{ 2 + 2}

// а тут посчитается
let val = sum.Force()

seq { for i in 0 .. 3 -> (i,i*i) }

async { let req  = WebRequest.Create("http://moma.org/")
        let! resp  = req.GetResponseAsync()
        let stream = resp.GetResponseStream()
        let reader = new StreamReader(stream)
        let! html = reader.ReadToEndAsync()
        html }

As you saw in Chapter 9, the key to understanding the F# workflow syntax is always to
understand the meaning of let!. In the case of async workflows, let! executes one asynchro-
nous computation and schedules the next computation for execution once the first
asynchronous computation completes.

async.Delay(fun () ->
   async.Let(WebRequest.Async("http://moma.org/"), (fun req ->
      async.Bind(req.GetResponseAsync(), (fun resp ->
         async.Let(resp.GetResponseStream(), (fun stream ->
            async.Let(new StreamReader(stream), (fun reader ->
               async.Bind(reader.ReadToEndAsync(), (fun html ->
                  async.Return(html))))))))))

// это простое выражение
let sum = <@  2 + 2 @>

// а это выражение, в котором можно потом специфицировать часть
let genFun = <@ 2 + _ @>

// и его можно специфицировать вот так
// после выполнения значение anotherFun будет <@ 2 + 1 @>
let anotherFun = genFun <@ 1 @>

// а можно и так
let yetAnotherFun = genFun <@ cos(0) @>
//после выполенения значение yetAnotherFun будет <@ 2 + cos(0) @>

CHAPTER 3 Introducing Functional Programming
CHAPTER 4 Introducing Imperative Programming

Passing and Processing Messages
A distinction is often made between shared-memory concurrency and message passing
concurrency. The former is often more efficient on local machines and is covered in the section
“Using Shared-Memory Concurrency” later in this chapter. The latter scales to systems where
there is no shared memory, for example, distributed systems, and can also be used to avoid
performance problems associated with shared memory. Asynchronous message passing and
processing is a common foundation for concurrent programming, and in this section we look
at some simple examples of message-passing programs.

M>// тут сумма не вычислится
M>let sum = lazy{ 2 + 2}

M>// а тут посчитается
M>let val = sum.Force()
M>

let (!$) = Lazy.force
let val = !$ sum

M>Таким вот образом ересь проникает в мейнстрим, ага

S>> NB: ленивыми имеет смысл делать только "тяжелые" вычисления, бо текущая реализация ленивости в F# довольно тормозная (гораздо хуже, чем в Haskell )

#light

open System
open Lazy
type sc = System.Console

let inline (!$) = Lazy.force

type 'a CCell = Nil | Cons of 'a * 'a CCell Lazy

let rec fromArray arr pos =
    if pos < Array.length arr then Cons (arr.(pos), lazy fromArray arr (pos+1)) 
    else Nil
    
let runLazy arr () =
    let rec sum acc = function Nil -> acc | Cons (a, rest) -> sum (acc+a) (!$ rest)
    sum 0 (fromArray arr 0)
    
type 'a ECell = ENil | ECons of 'a * (unit -> 'a ECell)

let rec fromArrayE arr pos () =
    if pos < Array.length arr then ECons (arr.(pos), fromArrayE arr (pos+1)) else ENil
    
let runFun arr () =
    let rec sum acc = function ENil -> acc | ECons (a, rest) -> sum (acc+1) (rest())
    sum 0 (fromArrayE arr 0 () )
    
let measured act =
    let sd = System.Diagnostics.Stopwatch()
    sd.Start()
    act () |> ignore
    sd.Stop()
    double (sd.ElapsedMilliseconds) / 1000.0

do
    let data = [|1 .. 100000000 |]
    let timeL = measured (runLazy data)
    sc.WriteLine("runLazy time: {0} s", timeL);
    let timeF = measured (runFun data)
    sc.WriteLine("runFun time: {0} s", timeF);
    sc.ReadKey() |> ignore

let runLazy arr () =
    let rec sum acc (Lazy l) = match l with Nil -> acc | Cons (a, rest) -> sum (acc+a) rest
    sum 0 (lazy fromArray arr 0)

let httpViaTryFinally(url: string) =
let req = System.Net.WebRequest.Create(url)
let resp = req.GetResponse()
try
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let html = reader.ReadToEnd()
html
finally
resp.Close()

let httpViaUseBinding(url: string) =
let req = System.Net.WebRequest.Create(url)
use resp = req.GetResponse()
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let html