Wouldn't it be better if 0 means infinite recursion? I think it's a good thing to avoid functions that differs between an optional argument being zero and being left out.
/ Martin Stjernholm, Roxen IS
Previous text:
2003-03-06 12:58: Subject: negative indices in array ranges
levels might possibly be from -1 and up, -1 meaning infinite.
/ Mirar
Yes, but it feels illogical. The logical would be that level=0 should just return the value without copying, in my opinion.
I've never really liked that "zero" is the default value to any function. Allowing a syntax for default values would be much nicer, for instance
int foo(int|void zot=17) { }
where zot=17 if not given.
/ Mirar
Previous text:
2003-03-06 13:09: Subject: negative indices in array ranges
Wouldn't it be better if 0 means infinite recursion? I think it's a good thing to avoid functions that differs between an optional argument being zero and being left out.
/ Martin Stjernholm, Roxen IS
Or int foo(int zot=17) { }
It's sort of odd to have '|void' there as well, since the default value indicates that the parameter can be left out, and 17 is not void.
/ Per Hedbor ()
Previous text:
2003-03-06 13:12: Subject: negative indices in array ranges
Yes, but it feels illogical. The logical would be that level=0 should just return the value without copying, in my opinion.
I've never really liked that "zero" is the default value to any function. Allowing a syntax for default values would be much nicer, for instance
int foo(int|void zot=17) { }
where zot=17 if not given.
/ Mirar
Yes, that's even better.
/ Mirar
Previous text:
2003-03-06 13:15: Subject: negative indices in array ranges
Or int foo(int zot=17) { }
It's sort of odd to have '|void' there as well, since the default value indicates that the parameter can be left out, and 17 is not void.
/ Per Hedbor ()
On that note, it'd be nice to have named parameters:
void foo(string firstname="", string initial="", string lastname="");
and then using syntax such as: foo(firstname = "David"; lastname = "Hedbor")
get the method called like this =>
foo("David", "", "Hedbor")
That's probably kind of tricky to implement however.
/ David Hedbor
Previous text:
2003-03-06 13:15: Subject: negative indices in array ranges
Or int foo(int zot=17) { }
It's sort of odd to have '|void' there as well, since the default value indicates that the parameter can be left out, and 17 is not void.
/ Per Hedbor ()
why not just use a mapping for that?
ok, you can't control what elements are used in a mapping, but that would be something i'd like to see:
mapping("foo":string,"bar":int,"baz":array) gazong;
meaning that this mapping may only have the listed keys with the given types.
greetings, martin.
but i want gazong=([ "foo":"fu", "bar":3, "baz":somearray ]); to work...
greetings, martin.
Why?
/ Martin Nilsson (har bott i google)
Previous text:
2003-03-07 00:56: Subject: Re: syntax dreams (was: negative indices in array ranges)
but i want gazong=([ "foo":"fu", "bar":3, "baz":somearray ]); to work...
greetings, martin.
/ Brevbäraren
- to make it work with existing mappings. - to implement davids idea.
whcih then would turn void foo(string firstname="", string initial="", string lastname=""); into void foo(mapping("firstname":string, "initial":string, "lastname":string) data);
callable with any mapping.
greetings, martin.
void foo(Gazong data);
Looks nicer too.
/ Marcus Comstedt (ACROSS) (Hail Ilpalazzo!)
Previous text:
2003-03-07 01:20: Subject: Re: syntax dreams (was: negative indices in array ranges)
- to make it work with existing mappings.
- to implement davids idea.
whcih then would turn void foo(string firstname="", string initial="", string lastname=""); into void foo(mapping("firstname":string, "initial":string, "lastname":string) data);
callable with any mapping.
greetings, martin.
/ Brevbäraren
that doesn't work with mappings, which is actually the more important part.
greetings, martin.
If you really need to send a mapping, just make the constructor to Gazong accept a mapping, and then call
foo(Gazong(m));
Problem solved. :-)
/ Marcus Comstedt (ACROSS) (Hail Ilpalazzo!)
Previous text:
2003-03-07 01:32: Subject: Re: syntax dreams (was: negative indices in array ranges)
that doesn't work with mappings, which is actually the more important part.
greetings, martin.
/ Brevbäraren
Then use
class Gazong (string foo, int bar, array baz) {}
/ Martin Nilsson (har bott i google)
Previous text:
2003-03-07 00:24: Subject: syntax dreams (was: negative indices in array ranges)
why not just use a mapping for that?
ok, you can't control what elements are used in a mapping, but that would be something i'd like to see:
mapping("foo":string,"bar":int,"baz":array) gazong;
meaning that this mapping may only have the listed keys with the given types.
greetings, martin.
/ Brevbäraren
Because with a mapping there is no control that you're actually sending the correct data. Using a mapping with some construct that enforces entry names might work but I don't see the benefit. Using a data class works too, but again, what I like about named parameters is that you keep the simplicity (in the method) of normal parameters - there's no difference. Using mapping/object would make it obvious you're using a mapping or an object. :)
/ David Hedbor
Previous text:
2003-03-07 00:24: Subject: syntax dreams (was: negative indices in array ranges)
why not just use a mapping for that?
ok, you can't control what elements are used in a mapping, but that would be something i'd like to see:
mapping("foo":string,"bar":int,"baz":array) gazong;
meaning that this mapping may only have the listed keys with the given types.
greetings, martin.
/ Brevbäraren
On Fri, Mar 07, 2003 at 01:35:02AM +0100, David Hedbor @ Pike developers forum wrote:
Using a mapping with some construct that enforces entry names might work but I don't see the benefit.
the benefit would be that this type checking would be usefull in other situations too.
what I like about named parameters is that you keep the simplicity (in the method) of normal parameters - there's no difference.
well the difference is that they are named, vs. unnamed.
however on a different note, going back to your suggestion, actually:
void foo(string firstname="", string initial="", string lastname="");
is not needed at all to get named parameters, they are already named: you really only need this:
void foo(string firstname, string initial, string lastname); foo(firstname = "David", lastname = "Hedbor")
as a generally acceptable syntax to assign the values. i don't see a need to define the variables in a different way to make assigning them like this work.
void foo(string firstname="", string initial="", string lastname=""); would still be usefull, but for a different unrelated purpose, namely asigning default values, which was discussed in another thread.
greetings, martin.
however on a different note, going back to your suggestion, actually:
void foo(string firstname="", string initial="", string lastname="");
is not needed at all to get named parameters, they are already named: you really only need this:
void foo(string firstname, string initial, string lastname); foo(firstname = "David", lastname = "Hedbor")
as a generally acceptable syntax to assign the values. i don't see a need to define the variables in a different way to make assigning them like this work.
Well, I used = "" only to illustrate the use of default values as well. It is not needed but I do think either that or 'void|' would be needed. Otherwise you could sudddenly call methods in incorrect ways.
void foo(string firstname="", string initial="", string lastname=""); would still be usefull, but for a different unrelated purpose, namely asigning default values, which was discussed in another thread.
Of course. But I don't think
foo(string a, string b) should be enoug to use foo(b="value") but rather at least foo(string|void a, string b) or foo(string a ="", string b);
That said the:
ret = foo(var=value) syntax is probably not optimal. Rather a new construct would have to be used (and yes, it pretty much does look like a mapping without the ([ ]))., such as foo(var: value, var2: value)
/ David Hedbor
Previous text:
2003-03-07 01:46: Subject: Re: syntax dreams (was: negative indices in array ranges)
On Fri, Mar 07, 2003 at 01:35:02AM +0100, David Hedbor @ Pike developers forum wrote:
Using a mapping with some construct that enforces entry names might work but I don't see the benefit.
the benefit would be that this type checking would be usefull in other situations too.
what I like about named parameters is that you keep the simplicity (in the method) of normal parameters - there's no difference.
well the difference is that they are named, vs. unnamed.
however on a different note, going back to your suggestion, actually:
void foo(string firstname="", string initial="", string lastname="");
is not needed at all to get named parameters, they are already named: you really only need this:
void foo(string firstname, string initial, string lastname); foo(firstname = "David", lastname = "Hedbor")
as a generally acceptable syntax to assign the values. i don't see a need to define the variables in a different way to make assigning them like this work.
void foo(string firstname="", string initial="", string lastname=""); would still be usefull, but for a different unrelated purpose, namely asigning default values, which was discussed in another thread.
greetings, martin.
/ Brevbäraren
The difference is in what foo(0) means.
/ Marcus Comstedt (ACROSS) (Hail Ilpalazzo!)
Previous text:
2003-03-06 14:10: Subject: Re: negative indices in array ranges
On Thu, Mar 06, 2003 at 01:15:05PM +0100, Mirar @ Pike developers forum wrote:
int foo(int|void zot=17)
how is that different from:
int foo(int|void zot) { if (!zot) zot=17; }
greetings, martin.
/ Brevbäraren
int foo(int zot=17) is shorter and more readable than the equivalent
int foo(int|void zot) { if(zero_type(zot)) zot = 17; }
/ Johan Sundström (folkskådare)
Previous text:
2003-03-06 14:10: Subject: Re: negative indices in array ranges
On Thu, Mar 06, 2003 at 01:15:05PM +0100, Mirar @ Pike developers forum wrote:
int foo(int|void zot=17)
how is that different from:
int foo(int|void zot) { if (!zot) zot=17; }
greetings, martin.
/ Brevbäraren
Well, first, it's not particularly different from
int foo(int|void zot) { if (zero_type(zot)) zot=17; }
but then again, when I program Pike I rather have Pike think for me then me thinking for Pike. That's kind of the reason to use Pike. If I want to think a lot about what I do, I program in C.
Hence the construct
int foo(int zot=17) { }
would let Pike do the thinking, and I don't have to be even close to the ugly construct that zero_type is. The code also gets much clearer; it's easy to see that zot will be 17 if I don't specify it, instead of lurking around trying to find whatever default value there might be close to a zero_type.
It also better eliminates the chance that someone makes code like
int foo(int|void zot) { if (!zot) zot=17; }
where the function have the same behaviour for the argument 0 and no argument at all, where the behaviour doesn't really correspond to the argument, which is in my opinion rather ugly.
/ Mirar
Previous text:
2003-03-06 14:10: Subject: Re: negative indices in array ranges
On Thu, Mar 06, 2003 at 01:15:05PM +0100, Mirar @ Pike developers forum wrote:
int foo(int|void zot=17)
how is that different from:
int foo(int|void zot) { if (!zot) zot=17; }
greetings, martin.
/ Brevbäraren
I hope that construct will be possible with the new compiler, if it isn't already possible to create in todays.
/ Mirar
Previous text:
2003-03-06 14:20: Subject: Re: negative indices in array ranges
Well, first, it's not particularly different from
int foo(int|void zot) { if (zero_type(zot)) zot=17; }
but then again, when I program Pike I rather have Pike think for me then me thinking for Pike. That's kind of the reason to use Pike. If I want to think a lot about what I do, I program in C.
Hence the construct
int foo(int zot=17) { }
would let Pike do the thinking, and I don't have to be even close to the ugly construct that zero_type is. The code also gets much clearer; it's easy to see that zot will be 17 if I don't specify it, instead of lurking around trying to find whatever default value there might be close to a zero_type.
It also better eliminates the chance that someone makes code like
int foo(int|void zot) { if (!zot) zot=17; }
where the function have the same behaviour for the argument 0 and no argument at all, where the behaviour doesn't really correspond to the argument, which is in my opinion rather ugly.
/ Mirar
It's not difficult to implement something that automatically inserts the bytecode to do a zero_type check like that.
/ Martin Stjernholm, Roxen IS
Previous text:
2003-03-06 14:21: Subject: Re: negative indices in array ranges
I hope that construct will be possible with the new compiler, if it isn't already possible to create in todays.
/ Mirar
A (probably) more efficient way would be to move the stackadjustment code from apply_low.h to the bytecode, and let the default value handling be done there.
/ Henrik Grubbström (Lysator)
Previous text:
2003-03-06 15:06: Subject: Re: negative indices in array ranges
It's not difficult to implement something that automatically inserts the bytecode to do a zero_type check like that.
/ Martin Stjernholm, Roxen IS
pike-devel@lists.lysator.liu.se
-
Alexander Demenshin -
David Hedbor ＠ Pike developers forum -
Henrik Grubbstr�m (Lysator) ＠ Pike (-) developers forum
-
Johan Sundstr�m (folksk�dare) ＠ Pike (-) developers forum
-
Marcus Comstedt (ACROSS) (Hail Ilpalazzo!) ＠ Pike (-) developers forum
-
Martin Baehr -
Martin Nilsson (har bott i google) ＠ Pike (-) developers forum
-
Martin Stjernholm, Roxen IS ＠ Pike developers forum
-
Mirar ＠ Pike developers forum
-
Per Hedbor () ＠ Pike (-) developers forum