Self reference

    (define msg (o m . args)
    	((o m) args))

    (define o-self!
    	(let ([self 'dummy])
    		(begin
    			(set! self
    				(lambda (m)
    					(case m
    						[(first) (lambda (x) (msg self 'second x))]
    						[(second) (lambda (x) x)])))
    			self)))
    ```

Pros: Simple.

Cons: The semantics must allow mutation.

    (define msg/self (o m . args)
    	((o m) o args))

    (define o-self!
    	(lambda (m)
    		(case m
    			[(first) (lambda (self x) (msg/self self 'second x))]
    			[(second) (lambda (self x) x)])))
    ```

Pros: Simple & Do not require mutation.

Cons: `self` must be passed correctly by the caller.

According to Programming languages: Application and Interpretation, `self` should not be exposed to programmers but should only be done in desugaring.

    (define msg/self-app (o m . args)
    	(((o o) m) args))

    (define o-self!
    	(lambda (self)
    		(lambda (m)
    			(case m
    				[(first) (lambda (x) (msg/self-app self 'second x))]
    				[(second) (lambda (x) x)]))))
    ```

This one actually allows [Extensible/Open recursion](/programming-language-theory/concepts/extensible-open-recursion) using the [Divergent/Big omega combinator](/programming-language-theory/concepts/divergent-big-omega-combinator).