digitalmars.D - Function sets as definable type
I'm not exactly sure how to explain this idea, but I'll do my best and hopefully I don't confuse anybody... D is one of many statically-typed languages which supports overloading functions by parameter type and parameter count. Many of these languages also support function pointers / delegates, but these have the limitation of only pointing to a single function. I've yet to encounter a language that can define a function pointer or delegate which points to two or more overloaded functions. To me, this is akin to how C handles arrays which requires passing pointer and length pairs as separate arguments. It's possible to do this in D statically via template alias parameters, but not dynamically via a function argument. Likewise, you can't easily limit it to a subset of the function overloads (two or more, but not all). I'm sure somebody could design an elegant solution using the meta-programming abilities of D, but I think I have a better idea... Consider internally, such a type would be a set of two or more functions / delegates. Internally, this is exactly what interfaces are as well. So that's my proposal: Allow implicitly casting a set of overloaded functions to a compatible interface. If a function is passed as an argument to an interface parameter, the compiler will automatically generate a binding of that function to that interface. I used the term "compatible interface" as obviously, not all interfaces would work. I'd rather leave it to the community to define what a "compatible interface" is. What use cases are there? Well, properties are also overloaded functions, one which gets the value, and one or more which sets the value. There are many cases in which a container doesn't allow handling elements as l-values, such as when opIndex and opIndexAssign are used, and ranges don't require .front and .back to be l-values. The result is that specialized functions must be written to handle these cases, one example being std.algorithm which implements a private function swapAt to handle the former case. I've had to do this myself, implementing a function, swapFront, to swap the front elements of two forward ranges. A more complex case is how to handle opIndex and opIndexAssign. Not all containers implement it as an l-value, which would prevent such a case from working: swap(r[a], r[b]). I'm sure there are more complex cases as well. In these situations, it would be great if a property could be generated from any arbitrary expression. Special standard library functions / templates could be used to auto-generate compatible interfaces. For example, we could define a template which takes the get / set types as arguments and generates an interface for it: void foo(Property!(int, int) prop){ } Thoughts?
Nov 23 2013
On Saturday, 23 November 2013 at 18:41:23 UTC, Xinok wrote:... Consider internally, such a type would be a set of two or more functions / delegates. Internally, this is exactly what interfaces are as well.Actually, could somebody elaborate on this for me please? With a little more thought, I realize that I'm probably wrong about this.
Nov 23 2013
On Saturday, 23 November 2013 at 20:49:00 UTC, Xinok wrote:On Saturday, 23 November 2013 at 18:41:23 UTC, Xinok wrote:This is doable as library now, with a struct, opDispatch and compile time reflection.... Consider internally, such a type would be a set of two or more functions / delegates. Internally, this is exactly what interfaces are as well.Actually, could somebody elaborate on this for me please? With a little more thought, I realize that I'm probably wrong about this.
Nov 24 2013