There is a trick to get this to work with gcc. The feature isn’t fully implemented yet, but you can structure the code to avoid the unimplemented sections. Manually expanding a variadic template into a parameter list won’t work. But template specialization can do that for you. template< char head, char … rest > struct … Read more
While the question is for Python 2.7 and already has an excellent answer, I had the same question for Python 3.3 and this thread was the closest thing to an answer I could find with Google. I found a better solution for Python 3.x by digging through the Python documentation, and I’m sharing my findings … Read more
I think this trait does what you want. It detects operator() with any kind of signature even if it’s overloaded and also if it’s templatized: template<typename T> struct is_callable { private: typedef char(&yes)[1]; typedef char(&no)[2]; struct Fallback { void operator()(); }; struct Derived : T, Fallback { }; template<typename U, U> struct Check; template<typename> static … Read more
If you’re using Rails, it provides a method called #constantize that will work: irb(main):017:0> Object.const_get ‘House::Owns’ NameError: wrong constant name House::Owns ‘House::Owns’.constantize => House::Owns
Ruby provides methods for this, instance_variable_get and instance_variable_set. (docs) You can create and assign a new instance variables like this: >> foo = Object.new => #<Object:0x2aaaaaacc400> >> foo.instance_variable_set(:@bar, “baz”) => “baz” >> foo.inspect => #<Object:0x2aaaaaacc400 @bar=\”baz\”>
Metaprogramming is possible in .NET (see compiler compilers, regular expressions, code DOM, reflection etc.) but C# is not capable of template metaprogramming because it does not have that language feature.
No, this is not possible. Generics are not as powerful as templates. For instance, a template argument can be a user-defined type, a primitive type, or a value; but a generic template argument can only be Object or a subtype thereof. Edit: This is an old answer; since 2011 we have Java 7, which has … Read more
If I understand your question correctly, you want something like this: class Product class << self [:name, :brand].each do |attribute| define_method :”find_by_#{attribute}” do |value| all.find {|prod| prod.public_send(attribute) == value } end end end end (I’m assuming that the all method returns an Enumerable.) The above is more-or-less equivalent to defining two class methods like this: … Read more
Like this: module M def self.before(*names) names.each do |name| m = instance_method(name) define_method(name) do |*args, &block| yield m.bind(self).(*args, &block) end end end end module M def hello puts “yo” end def bye puts “bum” end before(*instance_methods) { puts “start” } end class C include M end C.new.bye #=> “start” “bum” C.new.hello #=> “start” “yo”
I believe this notion comes from Lisp languages. Program written in Lisp consists of series of lists of lists of lists etc, like this: (defn f [x y] (+ x y)) Because of such uniformity it is possible to represent and manipulate such code as data, so the sequence of characters above is interpreted as … Read more