digitalmars.D - Structs and Variadic Functions

Xinok <xknnet gmail.com> writes:
I think combining structs with variadic functions can introduce some new
interesting possibilities.

struct SS{
int a, b, c;
}
static SS obj = {10, 20, 30}; // Full initalization
static SS obj = {a : 15, c : 35}; // Partial initalization

Apply this to a variadic function:
void func(SS arg ...){
writefln(arg.a);
writefln(arg.b);
writefln(arg.c);
}

int main(){
func(15, 30, 45); // Full initalization
func(b : 45, c : 30); // Partial initalization
}

In response to my last two suggestions:
Using aliases for constants - I greatly misunderstood how 'const' works in D.
As long as you initalize the variable, D forces the expression to be constant.
static int a;
const int* ptr = &a; // OK
const int* ptr = new int; // Error: non-constant expression new int

Virtual Import - I didn't think this was a great idea anyways. I was just
trying to suggest a way to define aliases for modules.
Dec 17 2006
"Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Xinok" <xknnet gmail.com> wrote in message
news:em4ctn$hhu$1 digitaldaemon.com...
I think combining structs with variadic functions can introduce some new
interesting possibilities.

struct SS{
int a, b, c;
}
static SS obj = {10, 20, 30}; // Full initalization
static SS obj = {a : 15, c : 35}; // Partial initalization

Apply this to a variadic function:
void func(SS arg ...){
writefln(arg.a);
writefln(arg.b);
writefln(arg.c);
}

int main(){
func(15, 30, 45); // Full initalization
func(b : 45, c : 30); // Partial initalization
}

I really like that. It also wouldn't impose any extra overhead, since the size of the structure on the stack would be the same size as if you were to pass those parameters, and accessing those struct members in the function would also be virtually the same as accessing parameters.
Dec 17 2006
Kenny <seriousmoose yahoo.com> writes:
I would also like to see this. One of my favourite things about js, is that I
can
send it an assoc array of whatever I want... functions, floats, strings,
integers,
and the ones I don't send are null. having that for functions would be
AMAZING...
I think it's not that hard to implement either. I suppose one could push on the
stack a list of pointers in the order they appear in the struct... the null ones
being uninitialized. then, inside of the function, the values will have to be
loaded, grabbing the value of a pointer. Technically, you can already do
something
similar though, by setting default values for all params to the function.

1. but, you can't call them unordered, referencing only the names.
2. if you know you want the first and third argument initialized, then it's
weird
to skip the second.

hmmmmm. this is a really good idea.
Dec 19 2006
Xinok <xnknet gmail.com> writes:
The main use I saw for this feature was passing properties to a function. Take
for
example, a file class:

class File{
private struct FProp{
string path; // Path to the file to open
int cache; // File cache
bool temp; // Temporary file?
bool binary; // Open file in binary mode?
}

this(FProp prop ...); // Constructor
}

int main(){
File ifile(path : "C:\\in.dat", read : true, cache : 4096);
File ofile(path : "C:\\out.dat", write : true, cache : 0, temp : true);
}

You only set the properties you need, and in any order you want.
Dec 19 2006
Reiner Pope <xxxxxx xxx.xx> writes:
Xinok wrote:
I think combining structs with variadic functions can introduce some new
interesting possibilities.

struct SS{
int a, b, c;
}
static SS obj = {10, 20, 30}; // Full initalization
static SS obj = {a : 15, c : 35}; // Partial initalization

Apply this to a variadic function:
void func(SS arg ...){
writefln(arg.a);
writefln(arg.b);
writefln(arg.c);
}

int main(){
func(15, 30, 45); // Full initalization
func(b : 45, c : 30); // Partial initalization
}

parameters. Some other languages have this already (for example, OCaml), but it doesn't require structs to do this. You can pick up the names of parameters from the prototype, and we already have support for default parameters. All you need now is support for naming parameters at the call-site, for which your syntax seems perfectly suitable. Then, you could avoid variadic functions and structs and just write: FilePtr openFile(char[] filename, bool read=true, bool write=true, bool append=false, bool anotherParam=false) {...} int main(){ openFile(filename : "asdf.txt", append : true); // Equivalent to openFile("asdf.txt", true, true, true, false); } Which is certainly a nice syntax feature to have. Cheers, Reiner
Dec 20 2006
"Kristian Kilpi" <kjkilpi gmail.com> writes:
On Thu, 21 Dec 2006 07:46:14 +0200, Reiner Pope <xxxxxx xxx.xx> wrote:
[snip]
Unless I misunderstand you, it seems you are suggesting named  =

parameters. Some other languages have this already (for example, OCaml=

but it doesn't require structs to do this. You can pick up the names o=

parameters from the prototype, and we already have support for default=

parameters. All you need now is support for naming parameters at the  =

call-site, for which your syntax seems perfectly suitable. Then, you  =

could avoid variadic functions and structs and just write:

FilePtr openFile(char[] filename, bool read=3Dtrue, bool write=3Dtr=

bool append=3Dfalse, bool anotherParam=3Dfalse) {...}

int main(){
openFile(filename : "asdf.txt", append : true);
// Equivalent to openFile("asdf.txt", true, true, true, false);
}

Which is certainly a nice syntax feature to have.

Cheers,

Reiner

Yes, indeed. I guess named parameters have been suggested before (in thi= s = NG)? Does Walter see it as a potential 2.0+ feature?
Dec 21 2006
Bill Baxter <dnewsgroup billbaxter.com> writes:
Reiner Pope wrote:
Xinok wrote:
I think combining structs with variadic functions can introduce some new
interesting possibilities.

struct SS{
int a, b, c;
}
static SS obj = {10, 20, 30}; // Full initalization
static SS obj = {a : 15, c : 35}; // Partial initalization

Apply this to a variadic function:
void func(SS arg ...){
writefln(arg.a);
writefln(arg.b);
writefln(arg.c);
}

int main(){
func(15, 30, 45); // Full initalization
func(b : 45, c : 30); // Partial initalization
}

parameters. Some other languages have this already (for example, OCaml), but it doesn't require structs to do this. You can pick up the names of parameters from the prototype, and we already have support for default parameters. All you need now is support for naming parameters at the call-site, for which your syntax seems perfectly suitable. Then, you could avoid variadic functions and structs and just write: FilePtr openFile(char[] filename, bool read=true, bool write=true, bool append=false, bool anotherParam=false) {...} int main(){ openFile(filename : "asdf.txt", append : true); // Equivalent to openFile("asdf.txt", true, true, true, false); } Which is certainly a nice syntax feature to have.

Dec 22 2006
Don Clugston <dac nospam.com.au> writes:
Bill Baxter wrote:
And this one's not about keyword args, but about default parameters and
function pointers in general. Started by Don Clugston.
http://www.digitalmars.com/d/archives/digitalmars/D/27291.html

Wow! That was my third ever D post!
Jan 09 2007
Xinok <xnknet gmail.com> writes:
Don Clugston Wrote:

Bill Baxter wrote:
And this one's not about keyword args, but about default parameters and
function pointers in general. Started by Don Clugston.
http://www.digitalmars.com/d/archives/digitalmars/D/27291.html

Wow! That was my third ever D post!

While this post is still here, I'd like to make this suggestion: We have the 'default' keyword, let's use it! void func(int a = 15, int b = 30, int c = 45); func(45, default, 60);
Jan 09 2007
David L. Davis <SpottedTiger yahoo.com> writes:
I like this idea...it makes a lot of sense to me.

David L.
Jan 09 2007
Pragma <ericanderton yahoo.removeme.com> writes:
Xinok wrote:
Don Clugston Wrote:

Bill Baxter wrote:
And this one's not about keyword args, but about default parameters and
function pointers in general. Started by Don Clugston.
http://www.digitalmars.com/d/archives/digitalmars/D/27291.html

While this post is still here, I'd like to make this suggestion: We have the 'default' keyword, let's use it! void func(int a = 15, int b = 30, int c = 45); func(45, default, 60);

Neat. I suppose 'default' could be used for non default args as well? void foo(int x); foo(default); // x = int.init -- - EricAnderton at yahoo
Jan 09 2007
Xinok <xnknet gmail.com> writes:
Xinok Wrote:

While this post is still here, I'd like to make this suggestion:
We have the 'default' keyword, let's use it!

void func(int a = 15, int b = 30, int c = 45);
func(45, default, 60);

Just one more thing I'd like to add, this could propose a slight problem with overloading functions: void func(int a = 15, int b = 30, int c = 45); void func(int a = 15, string b = "Thirty", int c = 45); func(45, default, 60); // Error - Cannot overload default argument A simple suggestion for this: func(45, default int, 60); func(45, default string, 60); To the original post, perhaps we could introduce a new kind of default parameter to D? Something like a 'static default argument'.
PROPOSAL
The solution is really very simple.

int afunc(int x, int y=3)
{
..dosomething
}

should be *identical* to declaring TWO functions:

int afunc(int x)
{
afunc(x, 3);
}

int afunc(int x, int y)
{
.. dosomething
}

I know nothing about assembly, but would it be possible to simply put all the initalizers into a single function, and depending on the type of the function pointer, it jumps to the proper location in the function to initalize the rest of the parameters? int func(int a = 15, int b = 30, int c = 45){ a = 15; // int func() b = 30; // int func(int) c = 45; // int func(int, int) return a + b + c; // int func(int, int, int) } IAW, if you were to create a pointer to this function: int delegate(int, int) ptr = &func; This delegate would point directly to the address of the code where you see 'c = 45' This would eliminate any performance issues and 'ghost functions'.
Jan 09 2007