Re: Make a function available under different names.
There are 2 ways you can solve your problem ```d string returnExecutableName(string[] arguments) { // if you compile with `-debug` it'll run this block debug { write("Debug mode is enabled.\n"); write(" Executable_Name: " ~ arguments[0] ~ "\n"); } return arguments[0]; } ``` ```d string returnExecutableName(string[] arguments) { // if you compile with `-version=VERBOSE` it'll run this block version (VERBOSE) { write("Debug mode is enabled.\n"); write(" Executable_Name: " ~ arguments[0] ~ "\n"); } return arguments[0]; } ``` You don't even need that function at this point ```d import std.stdio; void main(string[] args) { debug { write("Debug mode is enabled.\n"); write(" Executable_Name: " ~ args[0] ~ "\n"); } } ``` There, it's cleaner without indirections
Re: Make a function available under different names.
And here is my latest evolution of the code I've shared previously. ``` module utilities; import std.stdio : write; string returnExecutableName(string[] arguments, bool debugging=false) { if (debugging == true){ write("Debug mode is enabled.\n"); write(" Executable_Name: " ~ arguments[0] ~ "\n"); } return arguments[0]; } auto debugExecutableName(string[] arguments){ return returnExecutableName(arguments, true); } alias printExecutableName = debugExecutableName; alias getExecutableName = debugExecutableName; ``` ### Possible new syntax for D Alias? In this recent version of my code I noticed that it would be nice to have a new syntax for `alias` declaration. Syntax I would need in D language. `alias printExecutableName = getExecutableName = debugExecutableName;` In this syntax it would be easier to **declare multiple alias** that point to the same origin. Not sure if it would be a good idea, but an idea nonetheless.
Re: Make a function available under different names.
Here is some more updated code that works. ``` module utilities; import std.stdio : write; string returnExecutableNameFromMainFunction(string[] arguments, bool debugging=false) { if (debugging == true){ write("Debug mode is enabled.\n"); write(" Executable_Name: " ~ arguments[0] ~ "\n"); } return arguments[0]; } auto debugExecutableNameFromMainFunction(string[] arguments){ return returnExecutableNameFromMainFunction(arguments, true); } alias printExecutableNameFromMainFunction = debugExecutableNameFromMainFunction; alias getExecutableNameFromMainFunction = debugExecutableNameFromMainFunction; ```
Re: Make a function available under different names.
On Saturday, 29 July 2023 at 14:26:17 UTC, 4 wrote: Let's say I have these two functions: They have duplicate functionality. ``` string getExecutableNameFromMainFunction(string[] arguments){ write("Executable_Name: " ~ arguments[0] ~ "\n"); write("Debug mode is enabled.\n"); return arguments[0]; } string printExecutableNameFromMainFunction(string[] arguments){ write("Executable_Name: " ~ arguments[0] ~ "\n"); write("Debug mode is enabled.\n"); return arguments[0]; } ``` How can I easily and in simple way make `printExecutableNameFromMainFunction` as function where `getExecutableNameFromMainFunction` would share functionality or simply point to `printExecutableNameFromMainFunction`. Seems to be working ``` alias printExecutableNameFromMainFunction = getExecutableNameFromMainFunction; string getExecutableNameFromMainFunction(string[] arguments){ write("Executable_Name: " ~ arguments[0] ~ "\n"); write("Debug mode is enabled.\n"); return arguments[0]; } ```