• Chris Sauls <ibisbasenji gmail.com> Sep 10 2005
• pragma <EricAnderton youknowthedrill.yahoo> Sep 11 2005
• Deewiant <deewiant.doesnotlike.spam gmail.com> Sep 11 2005

Chris Sauls <ibisbasenji gmail.com> writes:

It might be useful if all types were implicitly castable to an array of one
element.  In 
other words, given a function:

# void foo (int[] x) {}

You could call it with:

# int bar = 123;
# foo(bar);

And it would be as if you had coded:

# int bar = 123;
# int[] tmp;
# tmp ~= bar;
# foo(tmp);

This is distinct from what can currently be done with type-safe variadics, in
that it is 
like an implied overload of (T[]) with (T), where the latter only dass
pass-thru.

Thoughts?  (This idea just randomly came to be a little bit ago.)

-- Chris Sauls

pragma <EricAnderton youknowthedrill.yahoo> writes:

Chris Sauls wrote:
 It might be useful if all types were implicitly castable to an array of 
 one element.  In other words, given a function:
 
 # void foo (int[] x) {}
 
 You could call it with:
 
 # int bar = 123;
 # foo(bar);
 
 And it would be as if you had coded:
 
 # int bar = 123;
 # int[] tmp;
 # tmp ~= bar;
 # foo(tmp);
 
 This is distinct from what can currently be done with type-safe 
 variadics, in that it is like an implied overload of (T[]) with (T), 
 where the latter only dass pass-thru.
 
 Thoughts?  (This idea just randomly came to be a little bit ago.)
 
 -- Chris Sauls


While I agree with the concept, it could cause some problems with 
function overloading.  So the best way forward for this would be to 
require an explicit cast which performs the 'promotion'.

 int bar;
 foo(cast(int[])bar);


While not as convenient, it allows you to have a function of the same 
name that accepts an int as an argument.

I can't see many places that this would be useful, but that's probably 
because former C/C++ devs like myself aren't used to being able to do 
stuff like this.  But I don't see any reason why the D language 
shouldn't be counted on to interpret things like this.

-- 
- EricAnderton at yahoo

Deewiant <deewiant.doesnotlike.spam gmail.com> writes:

pragma wrote:
 Chris Sauls wrote:
 
 It might be useful if all types were implicitly castable to an array
 of one element.  In other words, given a function:


 I can't see many places that this would be useful, but that's probably
 because former C/C++ devs like myself aren't used to being able to do
 stuff like this.
 


I, on the other hand, often find myself annoyingly reminded that
std.string.atoi() translates only strings, not characters.

Would definitely be a handy addition to the language, cast required or not.