- New`Base.@acquire` macro for a non-closure version of`Base.acquire(f, s::Base.Semaphore)`, like`@lock`. ([#56845])

- New`nth` function to access the`n`-th element of a generic iterable. ([#56580])

- New`@__FUNCTION__` macro to refer to the innermost enclosing function. ([#58909])

- The character U+1F8B2 🢲 (RIGHTWARDS ARROW WITH LOWER HOOK), newly added by Unicode 16,

is now a valid operator with arrow precedence, accessible as`\hookunderrightarrow` at the REPL.

([JuliaLang/JuliaSyntax.jl#525],[#57143])

@__DIR__,

@__LINE__,

@__MODULE__,

@__FUNCTION__,

@int128_str,

@uint128_str,

@big_str,

ispublic(m::Module, s::Symbol)=ccall(:jl_module_public_p, Cint, (Any, Any), m, s)!=0

macro__FUNCTION__()

Expr(:thisfunction)

isdeprecated(m::Module, s::Symbol)=ccall(:jl_is_binding_deprecated, Cint, (Any, Any), m, s)!=0

[FastClosures](https://github.com/c42f/FastClosures.jl) automate the

insertion of`let` statements as in`abmult3`.

For recursive closures specifically, the[`@__FUNCTION__`](@ref) macro can avoid both type instability and boxing.

First, let's see the unoptimized version:

functionmake_fib_unoptimized()

fib(n)= n<=1?1:fib(n-1)+fib(n-2)# fib is boxed

return fib

The`fib` function is boxed, meaning the return type is inferred as`Any`:

@code_warntypemake_fib_unoptimized()

Now, to eliminate this type instability, we can instead use`@__FUNCTION__` to refer to the concrete function object:

functionmake_fib_optimized()

fib(n)= n<=1?1: (@__FUNCTION__)(n-1)+ (@__FUNCTION__)(n-2)

return fib

This gives us a concrete return type:

@code_warntypemake_fib_optimized()

(define (make-assignment l r) `(= ,l ,r))

(define (assignment? e) (and (pair? e) (eq? (car e)'=)))

(define (return? e) (and (pair? e) (eq? (car e)'return)))

(define (thisfunction? e) (and (pair? e) (eq? (car e)'thisfunction)))

(define (tuple-call? e)

(and (length> e1)

(insert-after-meta `(block

,@stmts)

(cons `(meta nkw ,(+ (length vars) (length restkw)))

annotations))

(if (has-thisfunction? `(block ,@stmts))

(cons `(meta thisfunction-original ,(arg-name (car not-optional))) annotations)

annotations)))

rett)

(lambda (e)

(check-no-return e)

(check-no-thisfunction e)

(expand-generator e#f'()))

(if (has-return? e)

(error"\"return\" not allowed inside comprehension or generator")))

(define (has-thisfunction? e)

(expr-contains-p thisfunction? e (lambda (x) (not (function-def? x)))))

(define (check-no-thisfunction e)

(if (has-thisfunction? e)

(error"\"@__FUNCTION__\" not allowed inside comprehension or generator")))

(define (has-break-or-continue? e)

(expr-contains-p (lambda (x) (and (pair? x) (memq (car x)'(break continue))))

e

(define (lower-comprehension ty expr itrs)

(check-no-return expr)

(check-no-thisfunction expr)

(if (has-break-or-continue? expr)

(error"break or continue outside loop"))

(let ((result (make-ssavalue))

vi)

tab))

(Set'(quotetop core lineinfo line inert local-def unnecessary copyast

meta inbounds boundscheck loopinfo decl aliasscope popaliasscope

thunk with-static-parameters toplevel-only

global globalref global-if-global assign-const-if-global isglobal thismodule

global globalref global-if-global assign-const-if-global isglobal thismodule thisfunction

const atomic null true false ssavalue isdefined toplevel module lambda

error gc_preserve_begin gc_preserve_end export public inline noinline purity)))

((atom? e) e)

(else

(case (car e)

((quotetop core global globalref thismodule lineinfo line break inert module toplevel null true false meta) e)

((quotetop core global globalref thismodulethisfunctionlineinfo line break inert module toplevel null true false meta) e)

((toplevel-only)

(if (eq? (cadr e)'struct)

((error)

(error (cadr e)))

((thisfunction)

(let ((first-arg (and (pair? (lam:args lam)) (car (lam:args lam)))))

(if first-arg

(let* ((arg-name (arg-name first-arg))

(original-name (let ((body (lam:body lam)))

(and (pair? body) (pair? (cdr body))

(let loop ((stmts (cdr body)))

(if (pair? stmts)

(let ((stmt (car stmts)))

(if (and (pair? stmt) (eq? (car stmt)'meta)

(pair? (cdr stmt)) (eq? (cadr stmt)'thisfunction-original)

(pair? (cddr stmt)))

(caddr stmt)

(loop (cdr stmts))))

#f)))))

(final-name (or original-name arg-name)))

(cond (tail (emit-return tail final-name))

(value final-name)

(else (emit final-name)#f)))

(error"\"@__FUNCTION__\" can only be used inside a function"))))

(else

(error (string"invalid syntax" (deparse e)))))))