jackieku wrote:
Is there any plan to support variable length arguments for functions?
Yes. (However, it's a long way away.) The current plan is something like:
Code:
; Accept two or more params - collapse additional params into an object and assign to params var.
MyFunc(x, y, params*) {
; ...
; Expand contents of params obj into the parameter list:
OtherFunc(y, params*, x)
}
For example:
Code:
arr.insert(1, a, b, c)
; ...
Array_Insert(arr, index, items*){
Loop % items._MaxIndex()
arr._Insert(index++, items[A_Index])
Return arr
}
I also plan to change _Insert to accept a list of items to add (after the initial numeric index), so combined with this it could look like:
Code:
arr._Insert(index, items*) ; where 'items' is an object containing items to insert
I've been considering whether
named parameters need to be factored into the design. For instance,
MyFunc(Object(1,a,2,b,"name","foo")*) could potentially be equivalent to either
MyFunc(a, b) or
MyFunc(a, b, name: "foo"). From a user's perspective they might seem very similar, but they might require very different implementations.
majkinetor wrote:
I wouldn't give it priority because you can pass variable number of arguments by passing an object.
That isn't always feasible. I think that __get/__set/__call have much lower potential without the capability to accept an array of parameters. One example would be
dll.func(...) where
dll.func contains the address of a function and the types of its parameters.
Quote:
fun(Object(1, a1, 2, a2, ... n, an))
That is simply not practical. I plan to implement syntax sugar as below:
Code:
obj := [first, second, literal_key: value]
obj := Object(1, first, 2, second, "literal_key", value)
If * was supported, merging two arrays might be as simple as this:
Code:
z := [x*, y*]
I considered implementing [] syntax before named parameters, but again it might have a different set of requirements for implementation. I also considered implementing this and not named parameters, but I think allowing them in [ ] but not ( ) or requiring ([ ]) would be too inconsistent.
Another point is that if accepting parameters via an object causes a new object to be created (to store the parameters), the following three could be equivalent:
Code:
a := Object(1, x, 2, y, "n", z)
b := [x, y, n: z]
c := #(x, y, n: z)
#(items*) {
return items
}
All code in this post is pseudo-code and might never work.
Login
Register
FAQ
Search
that is not likely its more than 3000 lines without the includes from the bass library.
