WIP: Use (::Symbol) as curried getproperty

[Keno]

This implements the suggestion in #53946 (comment) and defines (s::Symbol)(x) = getproperty(x, s). In addition, we define getproperty(::Symbol, ::Symbol) to return the lens object I suggested in #53946. Together this satisfies the requirements I had for #53946 while not requiring any parser changes.

[Keno]

I've played around with this a little bit and I like it. Examples:

julia> :x.(Ref{Int}[1, 2])
2-element Vector{Int64}:
 1
 2

julia> :x.x.(Ref{Ref{Int}}.(Ref{Int}[1, 2]))
2-element Vector{Int64}:
 1
 2

julia> map(:x, Ref{Int}[1, 2])
2-element Vector{Int64}:
 1
 2

julia> map(:x.x, Ref{Ref{Int}}.(Ref{Int}[1, 2]))
2-element Vector{Int64}:
 1
 2

[jonas-schulze]

Suggested change

	This behavior feature at least Julia 1.14.
	This feature requires at least Julia 1.14.

[jonas-schulze]

Suggested change

	hieararchies. See also `(s::Symbol)(obj)`.
	hierarchies. See also `(s::Symbol)(obj)`.

[Seelengrab]

julia> map(:x, Ref{Int}[1, 2])
2-element Vector{Int64}:
 1
 2

To me this seems like an extremely odd pun on what map means.

julia> map(:x.x, Ref{Ref{Int}}.(Ref{Int}[1, 2]))
2-element Vector{Int64}:
 1
 2 

Does this mean Symbols are now effectively property lenses?

To be honest, I'm not a fan. The syntax looks very subtle and easy to skip when reading code. The distinction between property access on x and creating a lens is very slim, and even more so when property names get longer.

[jonas-schulze]

One could extend on the single-argument getproperty(syms):

julia> struct GetpropertyLens{N}
           syms::Tuple{Vararg{Symbol, N}}
       end

julia> Base.getproperty(s::Symbol) = GetpropertyLens((s,))

julia> Base.getproperty(syms::Tuple{Vararg{Symbol, N}}) where {N} = GetpropertyLens(syms)

julia> function (lens::GetpropertyLens)(strct)
           syms = getfield(lens, :syms)
           isempty(syms) && return strct
           sym = first(syms)
           return GetpropertyLens(Base.tail(syms))(Base.getproperty(strct, sym))
       end

julia> map(getproperty(:x), Ref{Int}[1, 2])
2-element Vector{Int64}:
 1
 2

julia> map(getproperty((:x, :x)), Ref{Ref{Int}}.(Ref{Int}[1, 2]))
2-element Vector{Int64}:
 1
 2

@Seelengrab, what do you think about this?

[Seelengrab]

@jonas-schulze please see #53946 and the discussions within for proposing more variations on syntax for this feature.

[jonas-schulze]

@jonas-schulze please see #53946 and the discussions within for proposing more variations on syntax for this feature.

I did. My subscription to that issue has brought me here. I simply meant to address your concern by an epsilon modification of what Keno did here. Mind giving feedback (or a mere 👍 / 😕 / 👎 reaction) on my question?

[Keno]

Does this mean Symbols are now effectively property lenses?

That is the proposal, yes.

[Keno]

One could extend on the single-argument getproperty(syms):

To be clear, while I think this variant is fine, it does not meet my requirements. The whole point is that there needs to be a very short syntax for this, because i want to use it as an accessor.

[Keno]

FWIW, I do agree that it is not necessarily intuitive that Symbol has this call overload, but it does pass my general criteria in that:

1. I don't think there's any other obvious semantics for this. If you had told me it was implemented and asked me what it did, this is what I would think it did.
2. In the issue, @JeffBezanson said this is how things work in Clojure - I don't know the language, so I can't comment, but if so, precedent from other languages is always welcome.
3. Syntactically, I don't have a strong preference between .x.x and :x.x, I just didn't know the latter was available.