Let’s find a unary function f and an argument x such that such that (f x) is exactly (f x).

It’s not hard to guess that this is going to involve self-referentiality. Therefore a good guess for x is 'f.

So let’s write our function f such that (f 'f) is (f 'f):

(defn f [x] '(f 'f))
(f 'f)

It works!

Now, we need to anonymize f. So let’s rewite f in such a way that it will return (f 'f) not for all the arguments but only when we pass 'f to f:

(defn f [x] (list x (list 'quote x)))
(f 'f)

Now if we replace f by its definition, we get our quine:

((fn [x] (list x (list 'quote x))) '(fn [x] (list x (list 'quote x))))


(function quine(){
    console.log('(' + quine.toString() + ')();');



x = "x = %p; puts x %% x"; puts x % x


((lambda (x)
   (list x (list (quote quote) x)))
        (lambda (x)
         (list x (list (quote quote) x)))))


Python’s %r format conversion uses the repr() function to return a string containing the source code representation of its argument:

x = 'x = %r\nprint(x %% x)'
print(x % x)

With the new str.format:

x = 'x = {!r};print(x.format(x))';print(x.format(x))