标签: generic-programming

我有一个非常简单的功能使用static_assert.麻烦的是我想要static_assert在函数声明中涉及的行为 - 特别是推断返回类型.似乎没有任何地方可以插入,static_assert以便我可以在编译器无法推断出返回类型之前触发它.

到目前为止,我将返回类型推导和静态断言放在结构中.这将触发断言,这很好,但它仍然会在类型推导上产生错误,这是我想要消除的噪音.

#include <type_traits>
#include <functional>
#include <memory>
#include <map>
#include <iostream>
#include <string>
#include <cstdio>
#include <tuple>
#include <sstream>
#include <vector>
#include <algorithm>

template<typename T, typename X> struct is_addable {
    template<typename Test, typename Test2> static char test(decltype(*static_cast<Test*>(nullptr) + *static_cast<Test2*>(nullptr))*);
    template<typename Test, typename Test2> static int test(...);
    static const bool value = std::is_same<char, decltype(test<T, X>(nullptr))>::value;
};
template<typename T, typename X> struct is_addable_fail {
    static const bool value = is_addable<T, X>::value; …

我知道Go不支持模板或重载函数,但我想知道是否有任何方法可以进行某种泛型编程？

我有很多这样的功能:

func (this Document) GetString(name string, default...string) string {
    v, ok := this.GetValueFromDb(name)
    if !ok {
        if len(default) >= 1 {
            return default[0]
        } else {
            return ""
        }
    }
    return v.asString
}

func (this Document) GetInt(name string, default...int) int {
    v, ok := this.GetValueFromDb(name)
    if !ok {
        if len(default) >= 1 {
            return default[0]
        } else {
            return 0
        }
    }
    return v.asInt
}

// etc. for many different types

没有这么多冗余代码,有没有办法做到这一点？

将转换仅应用于树而不是everywhere使用SYB 的最佳方法是什么？例如,在下面的简化表达式中,有几个实例Var "x",我想只用第一个实例替换Var "y".

data Exp = Var String | Val Int | Plus Exp Exp |...

myExp = Val 5 `Plus` Var "x" `Plus` Val 5 `Plus` Var "x" ...

Var "x"

这不能用做Var "y"组合子,因为它会尝试改变的所有实例somewhere来everywhere.

编辑(发布后):看起来就像Var "x"我在寻找.

到底发生了什么:

"Couldn't match kind `*' against `#'"

我在使用TemplateHaskell(ghci -XTemplateHaskell)的GHCi中尝试以下内容

$(reify ''Show >>= dataToExpQ (const Nothing))

我希望得到一个Exp(这有一个Show的实例).我这样做是为了在应用程序中插入有关haskell类型的信息,使其可用作实际数据,而不是字符串.

我的目标是:

info :: Info
info = $(reify ''Show >>= dataToExpQ (const Nothing))

我真的不明白这个错误信息,反正是什么'#'？如果有#,是否有也# -> #还是* -> #？它是否与类型相关的类型有关(虽然我不知道那可能是什么)？

好的,所以我现在明白GHC有各种各样的层次结构,而'#'是一种特殊的未装箱类型.一切都很好,但为什么会弹出这个错误？也许未装箱的类型与genercis不相称？

我还不完全确定这对我有意义,因为我认为未装箱的类型是由编译器执行的优化.我还认为,如果存在数据实例,则需要存在可能包含在数据结构中的所有类型.

经过进一步调查,我认为Names存在问题,有没有办法在dataToExpQ中规避它们？怎么用这个论点呢？

以下是g ++(STL的sgi版本)的STL实现的摘录.我想知道为什么他们使用部分特化而不是函数重载.

template <class InputIterator, class OutputIterator>
struct __copy_dispatch
{
  OutputIterator operator()(InputIterator first, InputIterator last,
                            OutputIterator result) {
    return __copy(first, last, result, iterator_category(first));
  }
};

//If the inputiterator and the outputiterator is all type T
//This is a partial specialization of the generalized version
template <class T>
struct __copy_dispatch<T*, T*>//-----------------------(1)
{
  T* operator()(T* first, T* last, T* result) {
    typedef typename __type_traits<T>::has_trivial_assignment_operator t; 
    return __copy_t(first, last, result, t());
  }
};

//Strictly speaking this is a partial specialization of the last …

我有一个VB.NET函数,如下所示,传递给函数的参数'x'是Type'Single'.但是,我想编写函数,以便它可以接受任何数字类型,如'Single','Double'和'Integer'.我知道这样做的一种方法是编写具有相同名称的3个函数,但它会非常繁琐.谁能提出任何想法？谢谢.

Public Function Square(x As Single) As Single
  Return x * x
End Function

我错过了几个课程,并没有真正理解流动的演讲幻灯片关于void指针的例子.

1. 在"no,no,no"这一行中,为什么我们不能因为P被分配了一个真正的指针类型q而不需要P？

2. 在"??"行中,将指针强制转换为整数是否合法？(我认为它可以编译,因为C不会检查强制转换,但不知道它将获得什么样的结果

在这个例子中 ,整数指针转换为
他铸造的整数*p = 10; a =(int)p; 并且有人回答说a将是一个非常大的价值.但在我的情况下,是(int)*p ...是否与我上面给出的例子相同？

3. 在最后一行,我对表达式感到困惑.*((int*)p)实际上是= p吗？谢谢!

是否可以在Scala中自动派生密封特征族的订单？

例如,能够这样做会很高兴:

sealed trait Letters
case object A extends Letters
case object B extends Letters

(A < B) == True

这感觉就像Shapeless可以处理的东西,但我不知道这是否存在.

如何在通用条件"where"中编写正确的Linq表达式

public static class ConStr
{
    public static MySqlConnection Conn()
    {
        return new MySqlConnection(ConfigurationManager.ConnectionStrings["DBCN"].ConnectionString);
    }

}

Repositor.cs

private IDbConnection cn;

public IEnumerable<TEntity> FilterBy(Expression<Func<TEntity, bool>> expression)
{
     using(cn = ConStr.Conn())
     {
        return cn.GetAll<TEntity>(null).Where(expression); <--error does not contain definition of where
     }

 }

但这与Linq表达式将运行

using (IDbConnection cn = ConStr.Conn()) 
{
    var que = cn.GetAll<Cause>(null).Where(x=>x.cause_id == 1);            
    bool dbIE = Utils.IsAny<Cause>(que);
    if (dbIE == true)
    {
        DGRID.DataSource = que;
    }
    else 
    {
        MessageBox.Show("Sorry No Value");
    }
}  

我对这些事情缺乏经验,但我正在尝试创建一个模板函数,在"旋转"参数下评估n变量函数(参见下面的示例)并返回所有这些值的向量.

例如,对于具有函数f(x,y,z)的n = 3,返回的三元\向量应该是

< f(x,0,0),f(0,x,0),f(0,0,x)>

我需要的天真版本可能如下所示(不必正确\工作)

typedef FunctionSignature Function;

template<class Function, size_t Dimensions>
std::array<Function::Out,Dimensions> F(Function::InComponent x)
{
  std::array<Function::Out,Dimensions> Result;

  for (i=0; i<Dimensions; i++)    
     Result[i] = Function::f("rotate((x,0,...,0),i)");

  return Result;
}

但是如何做到这rotate一点.

我也希望运行时for可以以某种方式被消除,因为n在编译时众所周知.