Qualche idea sulla costruzione di un programma Quine di ordine superiore?

Question

Qui è un programma speciale Haskell che emette un programma Python che genera un programma rubino che riproduce il programma originale Haskell (da http://blog.sigfpe.com/2008/02/third-order-quine-in-three-languages.html)

Per essere più precisamente, l'uscita è di questo programma Haskell

q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')'] 
main=q "q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')']" "def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'" "def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end" 

è un programma Python,

$ runhaskell test.hs 
def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')' 
q("def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'","def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')']") 

che emette un programma rubino dopo l'esecuzione,

$ runhaskell test.hs | python 
def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end 
q("def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')']","def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'") 

e infine il programma Ruby stampa il programma Haskell originale.

$ runhaskell test.hs | python | ruby 
q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')'] 
main=q "q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show C++ [','] ++ show a ++ [')']" "def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'" "def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end" 

Poiché un programma quine tradizionale può essere costruito separando un programma in due parti in cui parta contiene una descrizione di Partb e Partb calcola un dalla descrizione.

Ma come è stato costruito un quine di questo tipo?

Answer 1

In primo luogo, avvolgere la testa intorno a this programming assignment. Credimi, in realtà non è così difficile una volta che ci passi un po 'di tempo. L'idea è che puoi scrivere un programma che può prendere un altro programma come input e sputare un terzo programma come output che combina i due programmi e comprende anche il proprio testo. È una sorta di quine di ordine superiore. Se capisci la struttura di tutti e tre i linguaggi di programmazione, puoi prendere le idee da questo incarico e estenderle ulteriormente.

Answer 2

Kleene's recursion theorem in teoria consente di costruire un quine in quasi tutte le lingue. (More information here.) Sebbene io stesso non sia riuscito finora a farlo funzionare.

Per un ordine superiore, la funzione da considerare è la composizione dei meccanismi di valutazione delle lingue. Se riesci a ottenere un quine di base da KRT, potresti provare a ottenere un ordine superiore a quine.

Answer 3

Nel primo paragrafo di quell'articolo ho scritto una breve spiegazione. Consiglio di iniziare da lì.

Ho imparato alcune di queste tecniche dal libro Vicious Circles di Barwise e Moss. (! )

Answer 4

Io non sono un programmatore, ma suona come questo a me:

... -> C -> A -> B -> C> A-> B -> C -> ...

un cerchio (triangolo) vizioso senza inizio o fine reale.

programma A cointain una descrizione di B che contiene una descrizione di C.

programma B cointain una descrizione di C che contiene una descrizione di A.

programma C cointain una descrizione di A che contiene un descrizione di B.

Probabilmente andando più in profondità si può fare con molte lingue diverse ottenendo più angoli sul cerchio.