Bir dil homoikonik nasıl yapılır

Bu makaleye göre , aşağıdaki Lisp kodu satırı "Merhaba dünya" yı standart çıktıya yazdırır.

(format t "hello, world")

Homikonik bir dil olan Lisp, kodu veri olarak şu şekilde ele alabilir:

Şimdi aşağıdaki makroyu yazdığımızı hayal edin:

(defmacro backwards (expr) (reverse expr))

geriye doğru, bir ifadeyi (liste olarak temsil edilir) alan ve tersine çeviren makronun adıdır. İşte yine "Merhaba, dünya", bu sefer makroyu kullanarak:

(backwards ("hello, world" t format))

Lisp derleyicisi bu kod satırını gördüğünde, listedeki ( backwards) ilk atoma bakar ve makro adını verdiğini fark eder. Değerlendirilmemiş listeyi listeye ("hello, world" t format)yeniden düzenleyen makroya geçirir (format t "hello, world"). Sonuçta ortaya çıkan liste makro ifadesinin yerini alır ve çalışma zamanında değerlendirilecek olan budur. Lisp ortamı, ilk atomunun ( format) bir işlev olduğunu görecek ve onu değerlendirecek ve argümanların geri kalanını geçirecektir .

Lisp'te bu görevi gerçekleştirmek kolaydır (eğer yanlışsam beni düzelt) çünkü kod liste ( s-ifadeleri ?) Olarak uygulanır.

Şimdi bu OCaml (homoikonik bir dil değildir) snippet'ine bir göz atın:

let print () =
    let message = "Hello world" in
    print_endline message
;;

Lisp ile karşılaştırıldığında çok daha karmaşık bir sözdizimi kullanan OCaml'a homoiklik eklemek istediğinizi düşünün. Bunu nasıl yaptın? Homikoniklik sağlamak için dilin özellikle kolay bir sözdizimine sahip olması gerekir mi?

DÜZENLEME : Bu konudan Lisp'lerden farklı bir homoiklik elde etmenin başka bir yolunu buldum : io dilinde uygulanan . Bu soruya kısmen cevap verebilir.

Burada basit bir blokla başlayalım:

Io> plus := block(a, b, a + b)
==> method(a, b, 
        a + b
    )
Io> plus call(2, 3)
==> 5

Tamam, blok çalışıyor. Artı bloğu iki sayı ekledi.

Şimdi bu küçük adama biraz içgözlem yapalım.

Io> plus argumentNames
==> list("a", "b")
Io> plus code
==> block(a, b, a +(b))
Io> plus message name
==> a
Io> plus message next
==> +(b)
Io> plus message next name
==> +

Sıcak kutsal soğuk kalıp. Sadece blok parametrelerinin isimlerini elde etmekle kalmaz. Ve sadece bloğun tam kaynak kodunun bir dizesini elde etmekle kalmaz. Koda gizlice girip içindeki mesajları değiştirebilirsiniz. Ve en şaşırtıcısı: çok kolay ve doğal. Io'nun arayışına sadık. Ruby'nin aynası bunların hiçbirini göremiyor.

Ama, whoa whoa, hey şimdi, o kadrana dokunma.

Io> plus message next setName("-")
==> -(b)
Io> plus
==> method(a, b, 
        a - b
    )
Io> plus call(2, 3)
==> -1

Herhangi bir dili homoikonik yapabilirsiniz. Aslında bunu dili 'yansıtarak' yaparsınız (herhangi bir dil kurucusu için bu kurucunun veri olarak karşılık gelen bir temsilini eklersiniz, AST'yi düşünün). Ayrıca, alıntılama ve alıntıdan çıkarma gibi birkaç ek işlem eklemeniz gerekir. Bu aşağı yukarı.

Lisp, kolay sözdizimi nedeniyle bunu erkenden yaptı, ancak W. Taha'nın MetaML dil ailesi, herhangi bir dil için yapılabileceğini gösterdi.

Tüm süreç, homojen üretken meta-programlamanın modellenmesinde açıklanmaktadır . Aynı malzemeye daha hafif bir giriş burada .

Ocaml derleyici böylece, ocaml kendisi yazılır kesinlikle ocaml içinde Ocaml FBDTÖ işlemek için bir yolu yoktur.

ocaml_syntaxDile yerleşik bir tür eklediğinizi ve tür defmacrogirişi olan yerleşik bir işleve sahip olduğunu düşünebilirsiniz.

f : ocaml_syntax -> ocaml_syntax

Şimdi ne tip bir defmacro? Eh, bu girişe bağlıdır f, kimlik işlevi olsa bile , ortaya çıkan kod parçasının türü geçirilen sözdizimine bağlıdır.

Lisp'de bu sorun ortaya çıkmaz, çünkü dil dinamik olarak yazılır ve derleme zamanında hiçbir türün makronun kendisine atfedilmesi gerekmez. Bir çözüm sahip olmak

defmacro : (ocaml_syntax -> ocaml_syntax) -> 'a

bu da makronun herhangi bir bağlamda kullanılmasına izin verir . Ancak bu güvenli değildir, elbette, boola'nın yerine stringprogramın çalışma zamanında çökmesine izin verir .

Statik olarak yazılan bir dilde tek ilkeli çözüm , sonuç türünün girdiye bağlı olacağı bağımlı türlere sahip olmak defmacroolacaktır. Bu noktada işler oldukça karmaşıklaşıyor ve sizi David Raymond Christiansen'in güzel tezine yönlendirerek başlayacağım .

Sonuç olarak: sözdizimini dil içinde temsil etmenin pek çok yolu olduğundan ve muhtemelen quote"basit" sözdizimini dâhili içine gömmek için bir işlem gibi meta programlamayı kullanmak gibi karmaşık bir sözdizimine sahip olmak bir sorun değildir ocaml_syntax.

Sorun, özellikle tür hatalarına izin vermeyen bir çalışma zamanı makro mekanizmasına sahip olmak, bu tür yazılan yapmaktır.

Ocaml gibi bir dilde makrolar için bir derleme zamanı mekanizmasına sahip olmak elbette mümkündür, bkz. Örneğin MetaOcaml .

Ayrıca yararlı: Ocaml'de meta-programlama üzerine Jane Caddesi

Örnek olarak F # 'ı (OCaml temelli) ele alalım. F # tam olarak homoikonik değildir, ancak belirli durumlarda bir fonksiyonun kodunu AST olarak almayı destekler.

F #, senin printbir ile temsil edilir Exprolarak basılmış olması:

Let (message, Value ("Hello world"), Call (None, print_endline, [message]))

Yapıyı daha iyi vurgulamak için, bunu nasıl oluşturabileceğinizin alternatif bir yolu Expr:

let messageVar = Var("message", typeof<string>)
let expr = Expr.Let(messageVar,
                    Expr.Value("Hello world"),
                    Expr.Call(print_endline_method, [Expr.Var(messageVar)]))