Adding a language-feature-like functionality in Kotlin and Lisp for comparison. Using a simplified "using" statement as an example.

using.kt

// some setup

interface IDisposable {
    fun dispose()
}

data class Handle(val resource: String) : IDisposable {
    override fun dispose() {
        println("Disposing of $this")
    }
}

// the actual using's definition

inline fun <T : IDisposable> using(disposable: T, block: T.() -> Unit) = disposable.apply(block).dispose()

// usage

fun main() {
    using(Handle("fancy name")) {
        println("executing the code provided in using statement.. $resource")
    }
}

using.lisp

; some setup

(defclass handle()
    ((resource :initarg :resource)))

(defmethod dispose ((obj handle))
    (format t "~%Disposing of ~a"
            (slot-value obj 'resource))
    nil)

; the actual using's definition

(defmacro using (var form &body body)
    `(let ((,var ,form))
          (unwind-protect (progn ,@body)
                          (dispose ,var))))

; usage

(using x (make-instance 'handle :resource "fancy name")
       (format t "~%Executing code block while using: ~a"
            (slot-value x 'resource)))