可以说我的函数有以下（人为的示例）f：
data T where
T :: (Typeable a, Integral a) => { first :: a, second :: a } -> T
printType :: forall a. Typeable a => String
printType = show $ typeRep (Proxy :: Proxy a)
f :: T -> String
f (T first second) = show (toInteger first, toInteger second)
我也可以使用记录语法：
f (T {first, second}) = show (toInteger first, toInteger second)
但假设我想打印该类型。然后我使用类型应用程序：
f (T @a first second) = printType @a ++ ": " ++ show …假设我有一个长度相等的元组列表，其中每个元素都是整数或“星号”，例如：
[
(1, 2, *, 4, 5),
(1, *, 3, 4, 6),
(1, *, 3, 4, 5),
(1, 2, 3, 4, 6),
(4, *, *, 5, 6),
(*, *, 1, 5, 6)
]
在这种情况下，元素 1 和 3 重叠，2 和 4 重叠，5 和 6 重叠。
有没有一种方法可以在比简单方法更短的时间内确定是否存在重叠（我实际上不需要所有重叠，只需回答是否没有重叠或至少有一个重叠），即检查所有可能的对（其中是O(n^2)自然的）。
评论的澄清：
n上面给出的是行数。这就是可能变得很大的事情。出于此问题的目的，假设列数相对较小，例如不超过 20。
“星星”恰好代表一种元素。
基础中是否有任何新类型基本上可以实现以下目标？
newtype SemigroupFlip a = SemigroupFlip a
instance Semigroup a => Semigroup (SemigroupFlip a) where
(SemigroupFlip a) <> (SemigroupFlip b) = SemigroupFlip (b <> a)
instance Monoid a => Monoid (SemigroupFlip a) where
mempty = SemigroupFlip mempty
如果我们有以下内容:
template <class T>
struct B{
T data;
}
struct A{
int data_array[100];
}
int main()
{
A x;
const A x_const;
auto y1 = f(A());
auto y2 = f(x);
auto y3 = f(x_const);
auto y4 = f(std::move(x));
}
我想知道f(最好是功能,但宏也可以),这样:
decltype(y1) == B<A>
decltype(y2) == B<A&>
decltype(y3) == B<const A&>
decltype(y4) == B<A&&>
也就是说,f完美地x转化为一个对象B.
我一直在尝试在 Linux 上访问第六代 iPod nano。我尝试了Debian Squeeze自带的gtkpod，似乎不支持第6代nano。所以我在 wine 下尝试了 iTunes，它几乎没有安装并且功能不是很好。然后我在wine下尝试了foobar2000，它确实安装了，但似乎没有检测到我的ipod。
我现在尝试编译 gtkpod 2.0.2，但是在尝试编译 libgpod 时遇到 libtool 问题，我什至不知道 gtkpod 2.0.2 是否支持第六代 nano，尽管我确实看到了一些参考文献到 gtkpod 变更日志中的第六代 nano。
有人知道这里最好的方法吗？
根据我的理解,返回rvalues对函数的引用是危险的原因是由于以下代码:
T&& f(T&& x) { do_something_to_T(x); return static_cast<T&&>(x); }
T f(const T& x) { T x2 = x; do_something_to_T(x2); return x2; }
T&& y = f(T());
这留下y了一个未定义的悬空参考.
但是,我不明白为什么上面的代码甚至编译？是否有合理的理由将rvalue引用分配给另一个右值引用？粗略地说,rvalues不应该是"临时",即在表达结束时会变得无效吗？能够分配它们对我来说似乎很愚蠢.
当我尝试在ideone上编译以下内容时:
class X
{
public:
friend X& operator+=(X& x, const X& y);
};
X& operator+=(X& x, const X& y) { return x; }
int main()
{
X() += X();
}
正如所料,这会引发编译错误,因为您无法将临时传递给非const引用.
但是,以下内容在ideone上成功编译:
std::string() += std::string();
不应该像我上面的例子那样出错吗？
编辑:
如果std :: string()定义+=为成员操作,为什么在这样的用法允许左侧是临时的时候呢？为什么不像我上面那样定义它并避免引用临时问题？
可以说我有以下内容:
f :: a -> b -> c
g :: b -> c
g = f 10
现在让我们说f实际上:
f x y = f1 x + y
将:
g `seq` ...
实际上是评估f1 10,所以以后运行时
g 9
它实际上只是一个简单的添加？
如果没有,有没有办法"评估"部分应用功能的部分？
我在寻找一个通用的解决办法,不依赖于知道如何f和g工作.
在尝试使用时Data.Has,我一直在编写如下代码:
data Name = Name; type instance TypeOf Name = Text
type NameRecord = FieldOf Name;
我发现:
instance I NameRecord where
...
引发编译错误,即:
实例中的非法类型同义词系列应用程序
鉴于:
instance (NameRecord ~ a) => I a where
...
编译好.
我认为该错误与GHC中的此票证有关,标记为无效.
对机票的回应说:
我不确定你在暗示什么.我们无法自动转换
Run Code Online (Sandbox Code Playgroud)instance C (Fam Int) -- (1)成
Run Code Online (Sandbox Code Playgroud)instance (Fam Int ~ famint) => C famint -- (2)如果只有一个实例,则此方法有效,但只要有两个这样的实例,它们就会重叠.
也许你建议我们应该这样做,程序员应该只考虑隐式转换.我认为这不是一个好主意.令人困惑的是很少的好处(因为你总是可以轻松地自己编写转换后的实例).
有人可以详细说明这个解释,可能有一些示例代码,其中(1)失败,但(2)没有,为什么？
可以说我有以下内容:
data FuncAndValue v res = FuncAndValue (v -> res) v
chain :: (res -> new_res) -> FuncAndValue v res -> FuncAndValue v new_res
chain new_f (FuncAndValue old_f v) = FuncAndValue (new_f . old_f) v
被GHC可能能够结合功能new_f并old_f通过内联成一个单一的功能？
基本上,以数据类型存储函数无论如何都会抑制优化.
我希望GHC能够轻松地将函数链组合成一个(即所以我的结构上的"总和"不涉及重复调用代表的thunk,(+)而只是内联,(+)因此它像for循环一样运行.我希望将函数存储在数据类型中,然后稍后访问它们不会抑制它.