我正在观看Control.Lens介绍视频.
这让我想知道为什么Setter类型需要在仿函数中包装它.
它(大致)定义如下:
type Control.Lens.Setter s t a b = (Functor f) => (a -> f a) -> s -> f t
假设我有一个名为Pointthis的定义数据:
data Point = Point { _x :: Int, _y :: Int } deriving Show
然后我可以xlens像这样写自己的:
type MySetter s t a b = (a -> b) -> s -> t
xlens :: MySetter Point Point Int Int
xlens f p = p { _x = f (_x p) …我知道 Haskell 中的许多名称都受到范畴论术语的启发，我正试图准确理解类比的开始和结束位置。
Hask由于一些关于严格/懒惰和的技术细节，我已经知道这Hask不是（必然）一个类别seq，但现在让我们把它放在一边。为清楚起见，
Hask是具体类型，即 kind 的类型*。这包括像 那样的函数类型Int -> [Char]，但不包括像Maybe :: * -> *. 但是，具体类型Maybe Int :: *属于Hask. 类型构造函数/多态函数更像是自然变换（或其他更一般的映射Hask到自身），而不是态射。Hask是 Haskell 函数。对于两个具体类型Aand B，hom-setHom(A,B)是具有签名的函数集A -> B。f . g。如果我们担心严格性，我们可能会将组合重新定义为严格的，或者在定义函数的等价类时要小心。Functors 是 Endofunctors Hask我认为上面的技术细节与我下面的困惑没有任何关系。我想我理解它的意思是说 的每个实例Functor都是类别中的一个内函子Hask。也就是说，如果我们有
class Functor …我怎样才能让(a, a)一个Functor不诉诸newtype？
基本上我希望它像这样工作:
instance Functor (a, a) where
fmap f (x, y) = (f x, f y)
但当然,这不是表达它的合法方式:
Kind mis-match
The first argument of `Functor' should have kind `* -> *',
but `(a, a)' has kind `*'
In the instance declaration for `Functor (a, a)'
我真正想要的是这样的类型级函数:( \a -> (a, a)语法无效).也许这是一个类型别名？
type V2 a = (a, a)
instance Functor V2 where
fmap f (x, y) = (f x, f y)
我认为这会奏效,但事实并非如此.首先我得到这个投诉:
Illegal instance declaration …boost :: bind在很多情况下非常方便.其中之一是调度/发布一个方法调用,以便io_service稍后可以进行调用.
在这种情况下,boost :: bind的行为就像人们可能坦率地期望的那样:
#include <boost/asio.hpp>
#include <boost/bind.hpp>
boost::asio::io_service ioService;
class A {
public: A() {
// ioService will call B, which is private, how?
ioService.post(boost::bind(&A::B, this));
}
private: void B() {}
};
void main()
{
A::A();
boost::asio::io_service::work work(ioService);
ioService.run();
}
但是,据我所知,boost创建了一个functor(一个带有operator()()的类,能够在给定对象上调用给定的方法.该班级是否可以访问私人B？我猜不会.
我在这里错过了什么？
对不起有点初学者的问题.有矢量和矢量对
typedef std::vector <int> TItems;
typedef std::vector < std::pair <int, int> > TPairs;
有没有办法在一步中将对中的所有第一项转换为另一个向量
int main ()
{
TItems items;
TPairs pairs;
pairs.push_back (std::make_pair(1,3));
pairs.push_back (std::make_pair(5,7));
std::transform( items.begin(), items.end(), items.begin(), comp ( &pairs ) );
return 0;
}
如何设计仿函数？
class comp
{
private:
TPairs *pairs;
public:
comp ( TPairs *pairs_ ) : pairs ( pairs_) { }
unsigned int operator () ( const unsigned int index ) const
{
return (*pairs)[index].second != pairs->end(); //Bad idea
}
};
也许有一些没有lambda表达式和循环的用户友好方法.谢谢你的帮助.
我想知道FunctorHaskell中的实例在多大程度上由函子定律(唯一)确定.
由于ghc可以Functor为至少"普通"数据类型派生实例,因此它们似乎必须至少在各种情况下都是唯一的.
为方便起见,Functor定义和函子定律是:
class Functor f where
fmap :: (a -> b) -> f a -> f b
fmap id = id
fmap (g . h) = (fmap g) . (fmap h)
问题:
可以map从假设它是一个Functor实例开始得出定义data List a = Nil | Cons a (List a)吗？如果是这样,为了做到这一点,必须做出哪些假设？
是否有任何Haskell数据类型具有多个Functor满足函子定律的实例？
什么时候可以ghc派生出一个functor实例而什么时候不能呢？
所有这些都取决于我们如何定义平等吗？该Functor法律在价值的平等的条件下表达,但我们不要求Functors有Eq实例.那么这里有一些选择吗？
关于相等性,肯定存在一种我称之为"构造函数相等"的概念,它允许我们推断任何类型的任何值[a,a,a]都"等于",即使它没有为它定义.所有其他(有用的)平等概念可能比这种等价关系更粗糙.但我怀疑法律中的平等更多是"推理平等"关系,并且可以是特定于应用的.有什么想法吗？[a,a,a]aa(==)Functor
我一直在阅读一篇文章(http://comonad.com/reader/2012/abstracting-with-applicatives/)并在那里找到以下代码片段:
newtype Compose f g a = Compose (f (g a)) deriving Show
instance (Functor f, Functor g) => Functor (Compose f g) where
fmap f (Compose x) = Compose $ (fmap . fmap) f x
实际上是怎么样的(fmap . fmap)？
他们的类型是:
(.) :: (a -> b) -> (r -> a) -> (r -> b)
fmap :: (a -> b) -> f a -> f b
fmap :: (a -> b) -> f a -> f b
现在从这里我可以看出哪种类型没有检查 …
在思考如何推广monad时,我想出了一个仿函数F的以下属性:
inject :: (a -> F b) -> F(a -> b)
- 这应该是a和b中的自然变换.
如果没有更好的名称,如果存在上面显示的自然变换,我将函数F称为可绑定inject.
主要问题是,这个属性是否已经知道并且有一个名称,它是如何与仿函数的其他众所周知的属性相关的(例如,应用,monadic,尖头,可遍历等)
名称"可绑定"的动机来自以下考虑:假设M是monad而F是"可绑定"仿函数.然后有一个具有以下自然态射:
fbind :: M a -> (a -> F(M b)) -> F(M b)
这类似于monadic"bind",
bind :: M a -> (a -> M b) -> M b
除了结果用仿函数F装饰.
背后的想法fbind是,广义的monadic操作不仅可以产生单个结果M b,而且可以产生这种结果的"函数"F.我想表达一个monadic操作产生几个"计算线"而不仅仅是一个的情况; 每个"计算链"再次成为一元计算.
注意,每个仿函数F都具有态射
eject :: F(a -> b) -> a -> F b
这与"注入"相反.但并非每个仿函数F都有"注入".
具有"注入"的仿函数的示例:F t = (t,t,t) 或者F t = c -> (t,t)其中c是常量类型.F t = cFunctor(常量仿函数)或 …
monads haskell functional-programming functor category-theory
C++标准库函数按值获取functor(函数指针或函数对象)参数,如下所示:
template <typename F>
void apply(F func)
{
func();
}
......但是通过Universal Reference传递仿函数会不会更好？像这样:
template <typename F>
void apply(F&& func)
{
func();
}
这样,您可以传递维护状态的函数对象,并在返回高阶函数后访问该(可能已修改的)状态.
在Haskell中学习仿函数时,我想出了Functor.Indexed类型的仿函数.该仿函数定义了一个名为的操作imap.我不理解它的定义和imap签名:imap :: (a -> b) -> f j k a -> f j k b.我试图找到它的正式定义,只发现了这个:http://ncatlab.org/nlab/show/indexed+functor.但它根本没有帮助我.那么有人可以用更简单的词语澄清这种仿函数以及在什么情况下我应该使用它？谢谢.