Method of struct

[duan]

@lmiq

What one misses from the OO style is the autocompletion, but not the clarity of the syntax itself.

Since Julia doesn’t allow any function declaration other than constructors inside struct right now, one can imagine a new syntax that allows the declaration of the functions that are suitable for the dot syntax. For example,

struct Foo
    x
    function f(foo::Foo, x) end
end

f(foo:Foo, x) = (foo.x = x)

In this way, Julia can treat foo.f(x) as f(foo, x). And it also makes autocompleetion easier to implement in editors.

[duan]

@aplavin

The situation is julia is much more consistent than eg in python.

Agreed.

@aplavin

Just try using instruments that julia gives you for some time, and probably you won’t miss the dot notation anymore.

Maybe. But the dot syntax seems so natural in many cases that the same issue will be raised again and again as long as Julia attracts people. Why not make it a syntax sugar?

[DNF]

@duan

Why not make it a syntax sugar?

Hasn’t that been explained sufficiently?

[duan]

@DNF

Hasn’t that been explained sufficiently?

I guess it depends who you ask There’re things that one can manage to live without but will be happier to live with. Again, I’m not talking about piping or chaining for which elegant alternatives have been shown to exist.

[DNF]

@duan

one can imagine a new syntax that allows the declaration of the functions that are suitable for the dot syntax.

You can do that like this:

mutable struct Foo
    x::Float64
end
function Base.getproperty(obj::Foo, sym::Symbol)
    if sym == :f
        # return (val) -> setfield!(obj, :x, val)
        return (val) -> (obj.x = val)
    else
        return getfield(obj, sym)
    end
end

Then you can do

julia> obj = Foo(23.1)
Foo(23.1)

julia> obj.f(-4.2);

julia> obj
Foo(-4.2)

Do this for as many functions as you like. But it is not likely to become something that happens automatically.

[uniment]

I see the hornet’s nest has been kicked again

@dfdx

To support this (again, pretty specific) case, I wrote a simple macro @chainable

Thank you, I have added this to my running list of Julia macros which hope to address chaining/piping/threading/currying/partial evaluation/whatever it’s called. I have now collected links to eleven such packages.

@DNF

You can read this long, and still active, thread on the subject

I feel like my proposal (plus addendum) is now mature enough that I can split off into its own proposal thread.

[duan]

@DNF

You can do that like this:

mutable struct Foo
    x::Float64
end
function Base.getproperty(obj::Foo, sym::Symbol)
    if sym == :f
        # return (val) -> setfield!(obj, :x, val)
        return (val) -> (obj.x = val)
    else
        return getfield(obj, sym)
    end
end

It’s good except that it may not be (elegantly) generalized to more complicated cases and it adds a performance penalty.

[uniment]

due to constant propagation, there is no performance penalty.

it’s just a dog darn ugly solution.