标签: metaprogramming

是否可以将Ruby on Rails代码库转换为Python？

我认为很多人比Ruby更喜欢Python,但是发现Ruby on Rails功能(整体而言)比Python Web框架更好.

这样,有可能吗？或者Ruby on Rails是否使用难以转换为Python的特定于语言的功能？

给定一个容器来获取相关的迭代器很容易,例如:

std::vector<double>::iterator i; //An iterator to a std::vector<double>

我想知道在给定迭代器类型的情况下是否有可能推断出"相应容器"的类型(这里我假设每个容器都有一个且只有一个(非常量)迭代器).

更确切地说,我想要一个适用于所有STL容器的模板元函数(无需为每个单个容器手动专门化),例如:

ContainerOf< std::vector<double>::iterator >::type 

评估为

std::vector<double>

可能吗？如果没有,为什么？

预先感谢您的任何帮助!

我使用以下语法在Rails中的初始化程序中定义一个常量:

MyModule.const_set('MYCONSTANT','foobar')

它工作,如果我启动一个控制台并写

MyModule::MYCONSTANT 

我按预期收到了foobar.

问题是,当我尝试在模型中调用它时,常量不存在.

D应该在哪里动态定义我的常量,它在我的模型中也可以使用？

如果我在我的lib/mymodule.rb中静态定义它,它可以工作,但我想在运行时定义一些常量.

我无法通过const引用重载函数来获取值,或者如果它是rvalue则是rvalue引用.问题是我的非const左值绑定到函数的右值版本.我在VC2010中这样做.

#include <iostream>
#include <vector>

using namespace std;

template <class T>
void foo(const T& t)
{cout << "void foo(const T&)" << endl;}

template <class T>
void foo(T&& t)
{cout << "void foo(T&&)" << endl;}

int main()
{
    vector<int> x;
    foo(x); // void foo(T&&) ?????
    foo(vector<int>()); // void foo(T&&)
}

优先级似乎是推导foo(x)为

foo< vector<int> & >(vector<int>& && t)

代替

foo< vector<int> >(const vector<int>& t)

我尝试用r替换rvalue-reference版本

void foo(typename remove_reference<T>::type&& t)

但这只会导致所有内容都解析为const-lvalue引用版本.

我该如何防止这种行为？为什么这仍然是默认值 - 考虑到允许修改rvalue-references似乎很危险,这给我留下了意外修改的局部变量.

编辑:刚添加了非模板版本的函数,它们按预期工作.将函数设为模板会更改重载决策规则吗？那真是令人沮丧!

void bar(const vector<int>& t)
{cout << "void bar(const …

我目前正在努力使用以下代码,其目的是实现可变参数可变参数模板模板:

template
<
  template <typename... HeadArgs> class Head,
  template <typename... TailArgs> class...
>
struct join<Head<typename HeadArgs...>, Head<typename TailArgs...>...>
{
  typedef Head<typename HeadArgs..., typename TailArgs......> result;
};

理想情况下,我可以使用此模板元函数来实现以下功能:

template <typename...> struct obj1 {};
template <typename...> struct obj2 {};

typedef join
<
  obj1<int, int, double>, 
  obj1<double, char>,
  obj1<char*, int, double, const char*>
>::result new_obj1;

typedef join
<
  obj2<int, int, double>, 
  obj2<double, char>,
  obj2<char*, int, double, const char*>
>::result new_obj2;

/* This should result in an error, because there are 
   different encapsulating objects …

我正在努力学习Scala中的类型编程,并且我发现大多数关于类型编程需要知道的东西在值编程中都有类似的对应关系,这反映在类型级编程维基页面中.但是,我没有找到this关键词或自我类型的类比.我怀疑期待这样的事情可能没有意义,但我想我会问.

例如,我可以编写以下代码来表示Booleans在运行时的值:

sealed trait BoolVal {
  def not:BoolVal
  def or(that:BoolVal):BoolVal
  def and(that:BoolVal) =
    (this.not or that.not).not
  def imp(that:BoolVal) =
    this.not or that
}
case object TrueVal extends BoolVal {
  override val not = FalseVal
  override def or(that:BoolVal) = TrueVal
}
case object FalseVal extends BoolVal {
  override val not = TrueVal
  override def or(that:BoolVal) = that
}

这里我and和imp能够利用的事实,如果我是一个错误的对象或真实对象进行正确定义不要紧优势.我TrueVal和FalseVal对象可以继承相同的代码.

我可以制作类似的类型级编程结构,但我不明白如何定义And和Imp我的基本特征.

sealed trait BoolType {
  type …

在Excel中为各种数据导入方案生成SQL语句(主要是INSERT)有什么技巧吗？

我真的厌倦了用类似的方式编写公式

="INSERT INTO Table (ID, Name) VALUES (" & C2 & ", '" & D2 & "')"

我正在阅读John Resig的" Pro Javascript Techniques ",我对一个例子感到困惑.这是代码:

// Create a new user object that accepts an object of properties
function User( properties ) {
  // Iterate through the properties of the object, and make sure
  // that it's properly scoped (as discussed previously)
  for ( var i in properties ) { (function(){
  // Create a new getter for the property
  this[ "get" + i ] = function() {
    return properties[i];
  };
  // Create a new setter for the property
  this[ "set" …

我试图在python 2.7中动态生成类,我想知道你是否可以轻松地从类对象传递参数到元类.

我读过这篇文章很棒,但并没有完全回答这个问题.目前我正在做的事情:

def class_factory(args, to, meta_class):
    Class MyMetaClass(type):
        def __new__(cls, class_name, parents, attrs):
            attrs['args'] = args
            attrs['to'] = to
            attrs['eggs'] = meta_class

    class MyClass(object):
        metaclass = MyMetaClass
        ...

但这要求我做以下事情

MyClassClass = class_factory('spam', 'and', 'eggs')
my_instance = MyClassClass()

这样做有更干净的方法吗？

我正在读一本关于Rust的书,并开始玩Rust宏.所有元变量类型都在那里解释并有示例,除了最后一个 - tt.根据这本书,它是一个"单一的标记树".我很好奇,它是什么,它用于什么？你能举个例子吗？