Make include accept arbitrary number of string inputs

[baggepinnen]

This method will make include support a call syntax like

include(@__DIR__, "filename.jl")
include(path_variable, "filename.jl")

which is simpler than

include(joinpath(@__DIR__, "filename.jl"))
include(joinpath(path_variable, "filename.jl"))

This is my first PR to julia, I apologize in advance for any breach of protocol.

[musm]

This seems like it could be confusing; I'd almost think that
include("path_variable", "filename.jl") would include two files, not joinpath the input arguments.

[baggepinnen]

The inspiration came from Pkg.dir which has a built-in joinpath, together with the fact that include(joinpath is a very common pattern in Julia code.

The feedback the user would get upon trying to include multiple files would be immediate and rather easy to understand, and if the automatic joinpath makes it more likely that people will use it rather than chaining paths together with the multiplication operator I say it's worth the potential confusion opportunity. It would be documented of course so that all confusion goes away upon reading ?include

[StefanKarpinski]

I'd almost think that include("path_variable", "filename.jl") would include two files

Once upon a time, for a brief while, that's actually what it did: #19909. I have to say, this behavior makes more sense to me as a convenience, but the fact that there's two things it could mean makes me think it might be better to just require using joinpath explicitly.

[StefanKarpinski]

However, I have to say, this is a much more useful behavior for multi-arg include, imo.

[KristofferC]

Is this a bit of a slippery slope? Should all functions that take a path have a vararg joinpath version?

[JeffBezanson]

Welcome, @baggepinnen ! Thanks for the PR.

I have to say I don't really like this though; I'd prefer to keep include and joinpath orthogonal.

[baggepinnen]

I would personally like for consistent acceptance of multiple strings with automatic joinpath for all functions that accept a single string path, mostly because I appreciate when it's convenient to do things the right way. I was also considering a special multiplication operator between strings that does "path concatenation" by calling joinpath on its operands. Any thoughts on that idea?

[KristofferC]

JuliaLang/Juleps#26 maybe.

[baggepinnen]

That seems like a very promising idea, especially because the simple creation of the Path through the string macro.

[JeffBezanson]

In my experience this is the kind of thing that gives a bit of convenience in the short term, but pain in the long term as new cases are encountered. If a function accepts a path, it should just accept the path as one argument, and how you get the path is an orthogonal concern. That's the only thing guaranteed to work in all cases.

[rfourquet]

An example where multiple strings can be passed for convenience is warn/error, which are then not orthogonal to string.

[StefanKarpinski]

I suspect that @JeffBezanson doesn't care for that either.

[JeffBezanson]

I just see a lot of potential for confusion in this case. For example, ls and cat traditionally take multiple filename arguments, which conflicts with multiple path arguments implying joinpath. If you saw ls("a", "b") in julia you would have to guess which it means. And obviously, there are many operations on multiple paths like mv where the convention is not applicable. In general, varargs are intrusive since they prevent adding more positional arguments to a function in the future.

With warn and error I don't see as much potential confusion. One reason is that it's not possible to throw two errors at once, and printing two warnings at once (while possible) would be strange. In contrast, includeing multiple files is the common case, and so too for other file operations.