标签: metaprogramming

在Ruby中,我认为你可以调用一个尚未定义的方法,并捕获被调用方法的名称,并在运行时处理此方法.

Javascript可以做同样的事情吗？

假设我正在使用irb,并输入a = 5.如何删除定义,a以便键入a返回NameError？

一些背景:后来我想这样做:

context = Proc.new{}.binding
context.eval 'a = 5'
context.eval 'undef a'  # though this doesn't work.

假设我想编写一个泛型函数void f<T>(),如果T是POD类型则执行一项操作,如果T是非POD(或任何其他任意谓词)则执行另一项操作.

实现此目的的一种方法是使用标签库调用模式,如标准库与迭代器类别一样:

template <bool> struct podness {};
typedef podness<true> pod_tag;
typedef podness<false> non_pod_tag;

template <typename T> void f2(T, pod_tag) { /* POD */ }
template <typename T> void f2(T, non_pod_tag) { /* non-POD */ }

template <typename T>
void f(T x)
{
    // Dispatch to f2 based on tag.
    f2(x, podness<std::is_pod<T>::value>());
}

另一种方法是使用部分专用类型的静态成员函数:

template <typename T, bool> struct f2;

template <typename T>
struct f2<T, true> { static void f(T) { /* POD */ …

背景

考虑以下:

template <unsigned N>
struct Fibonacci
{
    enum
    {
        value = Fibonacci<N-1>::value + Fibonacci<N-2>::value
    };
};

template <>
struct Fibonacci<1>
{
    enum
    {
        value = 1
    };
};

template <>
struct Fibonacci<0>
{
    enum
    {
        value = 0
    };
};

这是一个常见的例子,我们可以将Fibonacci数的值作为编译时常量:

int main(void)
{
    std::cout << "Fibonacci(15) = ";
    std::cout << Fibonacci<15>::value;
    std::cout << std::endl;
}

但是你显然无法在运行时获得该值:

int main(void)
{
    std::srand(static_cast<unsigned>(std::time(0)));

    // ensure the table exists up to a certain size
    // (even though the rest of the code …

我需要在运行时为方法生成代码.能够运行任意代码并拥有文档字符串非常重要.

我想出了一个解决方案相结合exec,并setattr,这里是一个虚拟的例子:

class Viking(object):
    def __init__(self):
        code = '''
            def dynamo(self, arg):
                """ dynamo's a dynamic method!
                """
                self.weight += 1
                return arg * self.weight
            '''
        self.weight = 50

        d = {}
        exec code.strip() in d
        setattr(self.__class__, 'dynamo', d['dynamo'])


if __name__ == "__main__":
    v = Viking()
    print v.dynamo(10)
    print v.dynamo(10)
    print v.dynamo.__doc__

是否有更好/更安全/更惯用的方式来实现相同的结果？

情况:我有多个类,每个类应该包含一个带有配置哈希的变量; 每个类的不同哈希,但对于类的所有实例都是相同的.

起初,我试过这样的

class A
  def self.init config
    @@config = config
  end

  def config
    @@config
  end
end

class B < A; end
class C < A; end

但很快就注意到它不会那样工作,因为@@ config是在A的上下文中保存,而不是B或C,因此:

B.init "bar"
p B.new.config  # => "bar"
p C.new.config  # => "bar" - which would be nil if B had it's own @@config

C.init "foo"
p B.new.config  # => "foo" - which would still be "bar" if C had it's own @@config
p C.new.config  # => "foo"

我想过像这样使用它:

modules = [B, …

我试图让Matz和Flanagan的"Ruby Programming Language"元编程章节进入我的脑海,但是我无法理解我梦想的以下代码片段的输出:

p Module.constants.length           # => 88
$snapshot1 = Module.constants       
class A
  NAME=:abc

  $snapshot2 = Module.constants
  p $snapshot2.length               # => 90
  p $snapshot2 - $snapshot1         # => ["A", "NAME"]

end
p Module.constants.length           # => 89
p Module.constants - $snapshot1     # => ["A"]
p A.constants                       # => ["NAME"]

本书指出class方法constants返回类的常量列表(正如您在输出中看到的那样A.constants).当我遇到上述奇怪的行为时,我试图获取为Module类定义的常量列表.

A的常量出现在Module.constants中.如何获取Module类定义的常量列表？

该文档的状态

Module.constants返回系统中定义的所有常量.包括所有类和方法的名称

由于A继承了它的实现Module.constants,它在基类和派生类型中的表现如何？

p A.class               # => Class
p A.class.ancestors       # => [Class, Module, Object, Kernel]

注意:如果您使用的是Ruby 1.9, …

    template<int x> struct A {                                                                                                    
        template<int y> struct B {};.                                                                                             
        template<int y, int unused> struct C {};                                                                                  
    };                                                                                                                            

    template<int x> template<> 
    struct A<x>::B<x> {}; // error: enclosing class templates are not explicitly specialized

    template<int x> template<int unused> 
    struct A<x>::C<x, unused> {}; // ok

那么,如果外部类也不是专用的,为什么不允许内部嵌套类(或函数)的显式特化？奇怪的是,如果我只是简单地添加一个虚拟模板参数来部分地专门化内部类,我可以解决这个问题.使事情更丑陋,更复杂,但它确实有效.

我会将完全特化视为部分特化的子集 - 特别是因为您可以通过添加伪参数将每个完整的特化表示为部分.因此,部分和完全专业化之间的消歧对我来说并没有多大意义.

不幸的是,没有人在comp.std.c ++敢于回答,所以我再次以赏金把它放在这里.

注意:我需要此功能用于一组外部类的内部类的递归模板,而内部参数的特化确实取决于外部模板参数.

我们知道C++模板元编程是Turing完整的,但预处理器元编程却不是.

C++ 11为我们提供了一种新形式的元编程:constexpr函数的计算.这种计算形式是图灵完备吗？我在想,因为在constexpr函数中允许递归和条件运算符(？:),它会是,但我希望有更多专业知识的人来确认.

像Haskell(或Nemerle)这样的语言有quasiquotations.我想知道"准"是什么意思,如果没有"准"部分也存在"引用".