overloading

I am working on a project, and I have a generic abstract type that takes a type parameter that is itself derived from the abstract type. If you want to know why I would do this, please see this question . I have run into an interesting problem with overloading a method in a derived class that is defined in the abstract class. Here is a code sample: public abstract class AbstractConverter<T, U> where U : AbstractConvertible where T : AbstractConverter<T, U> { public abstract T Convert(U convertible); } public class DerivedConvertibleConverter : AbstractConverter<DerivedConvertibleConverter,

Why cannot F be deduced for proxy() ? It should be possible because I am restricting it - only for functions that return an int . #include <utility> #include <iostream> #include <type_traits> using namespace std; int foo(int bar) { cout << "int" << endl; return 2; } float foo(float bar) { cout << "float" << endl; return 1; } template <typename F, typename... Args> typename enable_if< is_same< typename result_of<F(Args...)>::type, int >::value, typename result_of<F(Args...)>::type >::type proxy(F func, Args&&... args) { return func(forward<Args>(args)...); } int main() { proxy(foo, 5); } Here

Function overloading by return type? has a very detailed answer on the rational on function overloading by return type, and from what I can see Delphi does not allow this, but are there any workarounds to overload a function based on different return type in Delphi? The implicit and explicit conversion operators for records permit overloading by return type: namely, the type being converted to: type TFoo = record class operator Implicit(const AFoo: TFoo): Integer; class operator Implicit(const AFoo: TFoo): string; end; Depending on the context, using a value of type TFoo will call the

I have been trying to generate a Factory supposed to return a different object of a common interface (say Item ) according to the input parameter (I call it a context) of the function getItem(A context) Now, assume I define a new type of context: B which inherits from A . I wanted to return a different item depending on whether the object passed to the factory was of class B or A . I tried to do as follows (overloading the method): class Factory { static Item getItem(A context) {...} static Item getItem(B context) {...} } This works fine if I do something like this: B bContext=new B(); Item it

I have a base class EventEmitter , which has the on method to bind handlers on specific events: class EventEmitter { on(event: string, handler: Function) { /* add handler internally */ } protected emit(event: string, ...args) { /* call all handlers listening on event */ } } Now I have various subclasses, which can emit different events with different arguments. I'd like to "declare" which events can be emitted by that specific class: class MyClass extends EventEmitter { on(event: 'event1', handler: (arg1: number) => void): void; on(event: 'event2', handler: (arg1: string, arg2: number) => void