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];
}
```
Make a function available under different names.
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`.
