Overloading path operators for easier concatenation

[torbenj]

Hey folks,

as I'm currently working a bit more with CakeBuild(-Frosting) I'm wondering if there is anything planned regarding to overloading operators on the DirectoryPath class for easier concatenation of paths?

The current solution to concatenate for example two DirectoryPath instances is to use the Combine method or CombineWithFilePath method if I want to add a file path to it.
The default way to combine path segments in .NET is to use Path.Combine but that would mean to mix APIs a lot when working with Cake and I think it's cleaner to just stick to the Cake way when working with it.

From C++ I'm used to have the / operator overloaded when working with their std::filesystem::path class to do concatenation and I think it would be quite nice to have it in Cake too.

Instead of having to do write something like this

var file = FilePath.FromString("baz.txt");
var dir  = DirectoryPath.FromString("C:").Combine("Foo").Combine("Bar").CombineWithFilePath(file);

using operator overloading we could shorten this to

var file = FilePath.FromString("baz.txt");
var dir  = DirectoryPath.FromString("C:") / "Foo" / "Bar" / file;

In this example I would interpret anything other than a FilePath parameter to the / operator of DirectoryPath as a segment for a directory path (and thus return a new DirectoryPath) and return a FilePath otherwise.

What do you think of this?
Is there maybe a better alternative already existing/in work?

[augustoproiete]

Hey @torbenj, that's an interesting conversation. Do you have some "real world" examples where overriding the / operator makes things better and/or easier to read that would be worth doing?

Your examples are great to showcase how the feature would work, but they are clearly an exaggerated way of using it (which fits the purpose). For instance, given C# has string interpolation, I would not expect anyone would want to do this:

var dir  = DirectoryPath.FromString("C:") / "Foo" / "Bar" / file;

When they can instead do this (much better & easier to read IMO):

var dir = DirectoryPath.FromString($"C:/Foo/Bar/{file}");

Are there cases where string interpolation are not working as expected which could potentially justify overriding the / operator or perhaps implement other implicit conversions on FilePath & DirectoryPath?

[devlead]

There was a PR to add divider operator overload, at that point we decided against it.

#1905

[gep13]

I remember that PR, I don't remember all the details of the conversation that we had though 😂

Happy to consider this again if there is a compelling reason to have it.

[torbenj]

Hey @torbenj, that's an interesting conversation. Do you have some "real world" examples where overriding the / operator makes things better and/or easier to read that would be worth doing?

I concatenate quite a lot of paths in our CI apps. Especially in more complex apps I tend to have dedicated functions that provide me with different paths I use throughout the application. These functions often times construct paths using other functions that provide the base paths for them.

Your examples are great to showcase how the feature would work, but they are clearly an exaggerated way of using it (which fits the purpose). For instance, given C# has string interpolation, I would not expect anyone would want to do this:

Sure my sample was an exaggeration. Most of the time I concatenate two or three segments.
I think the advantage of not using string interpolation is that the developer doesn't have to pay attention to platform specific ways of constructing paths like path separators under windows vs linux systems although I don't know how well cake supports different platforms as I'm currently using it on windows machines only. So yes I could use string interpolation but I prefer not to because of this at least.

Currently the Directory and File alias will give you an ConvertableDirectoryPath and ConvertableFilePath, these support the + operator

Ah ok didn't know that although I find this way quite a bit verbose too in contrast to just use strings without any aliases.

Citing from the mentioned PR #1905

We feel that this might lead to confusion about the intended purpose of the operator, i.e. is this a divide?

At least to me the + operator is more confusing in this context as I associate the + operator with simple string concatenation instead of constructing actual paths.
I personally think that "C:" / "Foo" / "Bar" represents path construction way better than Directory("C") + Directory("Foo") + Directory("Bar") as it better resembles what you would type into e.g. a console.

[nils-a]

I think the advantage of not using string interpolation is that the developer doesn't have to pay attention to platform specific ways of constructing paths like path separators under windows vs linux systems although I don't know how well cake supports different platform [...]

It does quite nicely. The code

var somePath = @"./the\direction/of\the/slash\is/irrelevant.txt";
var file = File(somePath);
Information(file);

does exactly the same on Windows, mac and linux: It will internally use ./the/direction/of/the/slash/is/irrelevant.txt and before really using it to access a file, always check what the operating system requires.

[augustoproiete]

These functions often times construct paths using other functions that provide the base paths for them.

It would be useful to see a couple of examples if you can provide them. You can see from the examples above that Cake takes care of normalizing the path to work as you'd expect in the OS where your Cake build is running, and you can mix and match paths using string interpolation or by using the + operator.