К>>Так вот, собственно: есть такая штука, как декорированные имена. И для С++ных dll это прекрасно работает. Хотя C++ в отказе от типизации обвинить сложно

typedef int (*PFN_Int_Int)(int);
#define MANGLE_Int_Int(s) s "@XZ" // наобум :) - лень смотреть настоящую декорацию

PFN_Int_Int foo = (PFN_Int_Int) GetProcAddress(hDLL, MANGLE_Int_Int("foo"));

["a", [1]] : list<string|list<int>>

 
type tree<'a> = 'a| list<tree<'a>>

["a", [1, "b"]] : tree<int|string>

There is no silver bullet

[:while, [:less, :r0, [:getb, :p2]],
  [:do,
    [:inc, :r3, [:getb, :p2]],
    [:inc, :r2, 1]     
  ]
]

D>Тут не понял. В чем проблема-то? Поскольку в лиспе типов нет, то это у него проблема: он не может проехаться по сложной иерархии и в ней выполнить некоторую операцию только над вхождениями определенного типа в иерархию

;------------------------------------------------------------------------
;            Extended tree fold
; tree = atom | (node-name tree ...)
;
; foldts fdown fup fhere seed (Leaf str) = fhere seed str
; foldts fdown fup fhere seed (Nd kids) =
;         fup seed $ foldl (foldts fdown fup fhere) (fdown seed) kids

; procedure fhere: seed -> atom -> seed
; procedure fdown: seed -> node -> seed
; procedure fup: parent-seed -> last-kid-seed -> node -> seed
; foldts returns the final seed

(define (foldts fdown fup fhere seed tree)
  (cond
   ((null? tree) seed)
   ((not (pair? tree))        ; An atom
    (fhere seed tree))
   (else
    (let loop ((kid-seed (fdown seed tree)) (kids (cdr tree)))
      (if (null? kids)
      (fup seed kid-seed tree)
      (loop (foldts fdown fup fhere kid-seed (car kids))
        (cdr kids)))))))

Z>>Интуитивно догадываться не нужно, есть книги, SICP например

[:while, [:less, :r0, [:getb, :p2]],
  [:do,
    [:inc, :r3, [:getb, :p2]],
    [:inc, :r2, 1]     
  ]
]

["a", [1]] : list<string|list<int>>

data Tree a = Leaf a | Tree a :^: Tree a

// Для примера C++, в котором виртуальные методы нужно объявлять явно.
class B {
};

class C : public B {
  public :
    void a() { std::cout << "C::a" << std::endl; }
};

C a;
a.a(); // Транслируется в call C::a.
a.b(); // Не транслируется вовсе.

# Ruby, поскольку я его хоть чуть-чуть знаю.
class B
end

class C < B
  def a; puts 'C#a'; end
end

a = C.new
a.a # Напечатает C#a
a.b # Выдаст ошибку времени исполнения. Но, если ее перехватить и продолжить...

# Класс B обновляется.
class B
  def b; puts 'B#b'; end
end

a.b # Ошибки уже не будет, а будет напечатано B#b.

 ...

'(while (less r0 (getb p2))
    (do
        (inc r3 (getb p2))
        (inc r2 1)))

'((op while) ((op less) (var r0) ((func getb) (var p2)))
    ((op do)
        ((func inc) (var r3) ((func getb) (var p2)))
        ((func inc) (var r2) (var l))))