标签: metaprogramming

我目前主要是D程序员,我希望在我的工具箱中添加另一种语言,最好是支持元编程黑客的语言,而这些语言无法用静态编译的语言完成.

我已经阅读了一点Lisp,我很想找到一种语言,允许Lisp做的一些很酷的东西,但没有Lisp的奇怪语法等.我不想开始语言火焰战,我确信Ruby和Python都有他们的权衡,所以我将列出对我个人来说重要的事情.请告诉我Ruby,Python或其他语言是否最适合我.

重要:

1. 好的元编程.能够在运行时创建类,方法,函数等.最好是代码和数据之间的最小区别,Lisp风格.
2. 漂亮,干净,理智的语法和一致,直观的语义.基本上是一个深思熟虑,有趣的使用,现代语言.
3. 多种范式.没有一个范例适用于每个项目,甚至是项目中的每个小子问题.
4. 一种有趣的语言实际上影响了人们对编程的看法.

有一些重要:

1. 性能.如果性能很好,那将是很好的,但是当性能是一个真正的优先级时,我将使用D代替.
2. 充分证明.

不重要:

1. 社区规模,图书馆可用性等.这些都不是语言本身的特征,而且所有这些都可以很快改变.
2. 工作可用性.我不是一名全职的专业程序员.我是一名研究生,编程与我的研究相关.
3. 任何主要针对非常大型项目设计的功能都会考虑到一百万个代码猴子.

>>> class A(object): pass
... 
>>> A.__dict__
<dictproxy object at 0x173ef30>
>>> A.__dict__.__dict__
Traceback (most recent call last):
  File "<string>", line 1, in <fragment>
AttributeError: 'dictproxy' object has no attribute '__dict__'
>>> A.__dict__.copy()
{'__dict__': <attribute '__dict__' of 'A' objects> ... }
>>> A.__dict__['__dict__']
<attribute '__dict__' of 'A' objects> # What is this object?

如果我这样做A.something = 10,这就进入了A.__dict__.什么是这个<attribute '__dict__' of 'A' objects>发现A.__dict__.__dict__,当它包含的东西吗？

我在关于haskell和函数式编程的博客中经常阅读这个术语(特别是在sigfpe的博客中),但我不清楚这是什么意思.我大部分时间都不知道,但如果我知道,我可能会更好地理解文本.谷歌没有帮助我.我迷失在技术方面.

此外,世界的非技术含义("改变抽象具体")并没有帮助我理解在代码中实现某些东西的实际意义.

我对计算机科学概念有点慢,所以使用代码的实际例子会很好.:P

我有一个模块MyModule.我动态地将类加载到其中.如何获取其命名空间中定义的类的列表？

例:

def load_plugins
  Dir.glob(File.dirname(__FILE__) + '/plugins/*.rb') do |f|
    MyModule.class_eval File.read(f)
  end

  # now how can I find the new classes I've loaded into MyModule?
end

我应该说每个都f包含类似"类Foo;结束"的内容.

您也可以这样想:在Rails中,我如何以编程方式查找ActiveRecord模块中定义的所有类？

只是一个快速而简单的问题:在PostgreSQL中,如果可能的话,如何使用只使用SELECT语句的表列出所有存储函数/存储过程的名称？如果一个简单的SELECT不够,我可以使用存储的函数.

我认为,我的问题与其他问题有些类似,但另一个问题是针对SQL Server 2005:
表中的存储过程列表

(可选)就此而言,您如何以相同的方式列出使用同一个表的触发器和约束？

如何使用名称在Ruby中动态定义类？

我知道如何动态创建一个没有名称的类使用类似的东西:

dynamic_class = Class.new do
  def method1
  end
end

但是你不能指定一个类名.我想用名称动态创建一个类.

这是我想要做的一个例子,但当然它实际上并不起作用.
(注意,我不是创建类的实例而是创建类定义)

class TestEval
  def method1
    puts "name: #{self.name}"
  end
end

class_name = "TestEval"
dummy = eval("#{class_name}")

puts "dummy: #{dummy}"

dynamic_name = "TestEval2"
class_string = """
class #{dynamic_name}
  def method1
  end
end
"""
dummy2 = eval(class_string)
puts "dummy2: #{dummy2}" # doesn't work

实际产量:

dummy: TestEval
dummy2: 

期望的输出:

dummy: TestEval
dummy2: TestEval2

================================================== ====

答:使用sepp2k方法的完全动态解决方案

dynamic_name = "TestEval2"

Object.const_set(dynamic_name, Class.new) # If inheriting, use Class.new( superclass …

我读了:

• 维基百科
• 代码生成与元编程
• 元编程艺术
• 在c2.com上进行元编程

我在元编程/代码生成背后的目的上承认了一些困惑.

有没有人有一个具体的例子,他们使用元编程/代码生成？更好的是伴随解释为什么它比替代品更好.

编辑:蓟是否会被视为元编程？

我不明白,在我看来,调用f是完全明确的,但它无法编译expected primary-expression before ‘int’.如果我通过调用注释掉该行f,它编译得很好.

template<typename T>
struct A {
    template<typename S>
    void f() { }
};

template<typename T>
struct B : A<T> {
    void g() {
        this->f<int>();
    }
};

据我所知,有三种方法可以在Ruby中动态调用方法:

方法1:

s = SomeObject.new
method = s.method(:dynamic_method)
method.call

方法2:

s = SomeObject.new
s.send(:dynamic_method)

方法3:

s = SomeObject.new
eval "s.dynamic_method"

通过对它们进行基准测试,我已经确定方法1是最快的,方法2是慢的,方法3是迄今为止最慢的.

我也发现,.call并且.send都允许调用私有方法,而eval不是.

所以我的问题是:有没有理由使用.send或eval？为什么你不总是只使用最快的方法？这些调用动态方法的方法有什么其他区别？

作为一个编程练习,我编写了一个Ruby片段,它创建了一个类,从该类中实例化了两个对象,monkeypatches一个对象,并依赖于method_missing来monkeypatch另一个.

这是交易.这按预期工作:

class Monkey

  def chatter
    puts "I am a chattering monkey!"
  end

  def method_missing(m)
    puts "No #{m}, so I'll make one..."
    def screech
      puts "This is the new screech."
    end
  end
end

m1 = Monkey.new
m2 = Monkey.new

m1.chatter
m2.chatter

def m1.screech
  puts "Aaaaaargh!"
end

m1.screech
m2.screech
m2.screech
m1.screech
m2.screech

你会注意到我有一个method_missing的参数.我这样做是因为我希望使用define_method动态创建具有适当名称的缺失方法.但是,它不起作用.实际上,即使使用带有静态名称的define_method也是如此:

def method_missing(m)
  puts "No #{m}, so I'll make one..."
  define_method(:screech) do
    puts "This is the new screech."
  end
end

结束以下结果:

ArgumentError: wrong number of arguments (2 for 1) …