How to discover functions which apply to a given object?

New to Julia
31

OK, if I want to push further for it I will consider making a proposal for it elsewhere. To address the arguments though:

While the language may not place special emphasis on the first argument, humans still do. Again, I’m not suggesting that this is a complete solution that is elegant and perfect in every use case, but it is amazingly useful in the other languages which have it.

There’s no ambiguity though - it tries getproperty and if it can’t find anything it tries a function. It’s not the only way to call a function, so if you happend to have a name conflict you just write the function the other way. Other languages (D, Nim) handle this exactly the same way.

If you really wanted to, xs.Statistics.quantile(ps), however it seems that Julia encourages pulling everything into the global namespace anyway so this wouldn’t happen that much.

Again, it’s meant as an option to use when it makes “grammatical” sense. It’s not meant to be the only way to apply a function, and it’s not meant to provide perfect discoverability, but it’s a fair bit better than what is possible now. It’s obvious these “grammatical” order differences are important, otherwise the pipe operator wouldn’t exist.

I’m not wed to the dot operator, it just feels natural because that’s what I’m used to. The pipe operator is promising, but currently limited to single-argument functions only which greatly neuters it’s usefulness. I would be perfectly happy if something like curry underscoring is implemented, as it would also allow true completion (i.e. typing your code in the same order whether you use completion or not). It is even more general than UFCS, at the expense of 5 extra characters of syntax. For example,

# Original method call:
connected_components(fill_from(A, edge_list), k)

# UFCS:
A.fill_from(edge_list).connected_components(k)

# Curry Underscoring Pipe:
A |> fill_from(_, edge_list) |> connected_components(_, k)

# Possible with Curry Underscoring, but not with UFCS:
some_array |> map(x->x^2, _)

# Splats are hopefully possible with Curry Underscoring?
C = (A_set, B_set)
C |> union(_...)

# Not sure about changing the order, for example
C |> func(_[2], _[1])
# but it doesn't have to be infinitely flexible,
# even UFCS provides a really decent level of flexibility.

Despite the noisier / cumbersome syntax I think I’m coming around on some sort of curry underscoring approach. It would work pretty well with completion, typing A |> <tab> could list all the methods which could take A in their input, auto-completing could even place the underscore where it should go based on type (if it was unambiguous). Limiting this auto-complete would be a challenge still, but it’s potentially progress.

1 Like