标签: functor

我对map()的行为很困惑.

我有一个这样的对象数组:

const products = [{
    ...,
    'productType' = 'premium',
    ...
}, ...]

我将这个数组传递给一个函数,该函数应返回相同的数组,但所有产品都是免费的:

[{
    ...,
    'productType' = 'free',
    ...
}, ...]

功能是:

const freeProduct = function(products){
    return products.map(x => x.productType = "free")
}

返回以下数组:

["free", "free", ...]

所以我重写了我的功能:

const freeProduct = function(products){
    return products.map(x => {x.productType = "free"; return x})
}

它按预期返回数组.

但是!那是我放松心情的时刻,在这两种情况下我的原始产品阵列都被修改了.

map()周围的文档说它不应该(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).

我甚至试图创建一个我的阵列的克隆,像这样转动我的功能

const freeProduct = function(products){
    p = products.splice()
    return p.map(x => {x.productType = "free"; return x})
}

但我仍然得到相同的结果(这开始让我发疯).

我会非常感谢任何可以解释我做错的人!

谢谢

这种类型让我大吃一惊:

class Contravariant (f :: * -> *) where
  contramap :: (a -> b) -> f b -> f a

然后我读了这个,但与标题相反,我不再开悟了.

有人可以解释逆变函子是什么以及一些例子吗？

我在标准n4296(草案)§1.8第7页中读到:

一个对象是存储的区域.[注意:函数不是对象,无论它是否以对象的方式占用存储. - 尾注]

我在网上花了几天寻找这种排斥的充分理由,没有运气.也许是因为我不完全理解对象.所以:

1. 为什么函数不是对象？它有何不同？
2. 这与仿函数(函数对象)有什么关系吗？

了解一下Haskell有一个关于仿函数的例子.我可以阅读LYAH和文本,并弄清楚应该发生什么 - 但我不知道写这样的东西.我经常在Haskell中发现这个问题.

instance Functor (Either a) where  
    fmap f (Right x) = Right (f x)  
    fmap f (Left x) = Left x

但是,我很困惑..为什么不这个补充

instance Functor (Either a) where  
    fmap f (Right x) = Right (x)  
    fmap f (Left x) = Left (f x)

如果f没有在顶部定义中使用,那么还有什么限制x使得它无法满足Left

这是这个问题的后续问题:具有任何参数列表的函数的泛型函子

我有这个仿函数类(完整代码见上面的链接):

template<typename... ARGS>
class Foo
{
    std::function<void(ARGS...)> m_f;
  public:
    Foo( std::function<void(ARGS...)> f ) : m_f(f) {}
    void operator()(ARGS... args) const { m_f(args...); }
};

在operator()中,我可以使用递归的"剥离"功能轻松访问args ...如http://www2.research.att.com/~bs/C++0xFAQ.html#variadic-templates

我的问题是:我想在构造函数中访问f的参数类型,即ARGS ....显然我无法访问值,因为到目前为止还没有,但参数类型列表以某种方式埋没在f中,不是吗？

应用函子是众所周知的,并且在Haskellers中广受欢迎,因为它们能够在有效的环境中应用函数.

在类别理论术语中,可以证明以下方法Applicative:

pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b

相当于有一个Functor f操作:

unit :: f ()
(**) :: (f a, f b) -> f (a,b)

这个想法是写pure你只是用给定的值替换()in unit,并写(<*>)你将函数和参数压缩到一个元组,然后在它上面映射一个合适的应用程序函数.

此外,这种对应关系变成了Applicative法律成左右自然monoidal十岁上下的法律unit和(**),所以实际上是一个适用函子也恰恰是一类理论家称之为一个宽松monoidal仿函数(松懈,因为(**)仅仅是一个自然的转变,而不是同构).

好的,很好,很棒.这是众所周知的.但是,这只是一个家庭不严monoidal函子-那些尊重的monoidal结构产品.松散的幺正算子涉及两种幺半群结构的选择,在源头和目的地:如果你把产品变成总和,你就会得到:

class PtS f where
  unit :: f Void
  (**) :: f a -> f b -> f (Either a b) …

我有点困惑,需要有人帮我.让我们概述一下我目前的理解:

Eendofunctor 在哪里,是一个A类别:

E : A -> A.

由于Haskell中的所有类型和态射都属于该Hask类别,Haskell中的任何函子都不是一个endofunctor？F : Hask -> Hask.

我有一种很好的感觉,我错了,并以某种方式过度简化了这一点,我希望有人告诉我,我是一个多么的白痴.谢谢.

void f(int){}
typedef void (*f_ptr)(int);

struct Functor{
  void operator()(int){}
};

struct X{
  operator f_ptr(){ return f; }
};

struct Y{
  operator Functor(){ return Functor(); }
};

int main(){
  X x; Y y;
  x(5); // works ?!
  y(5); // doesn't ?!
}

Ideone上的实例.输出:

错误:调用'(Y)(int)'不匹配

Q1:为什么调用x(5)允许,即使X只定义了转换为函数指针,而不是operator()？

Q2:相反,如果我们定义转换为另一个仿函数,为什么不允许相同的事情？

我刚刚Const在文档中找到了Control.Applicative,但是我很难找到有用的地方,而不是直接使用Monoid.

我错过了什么？

有没有一种情况,创建一个仿函数比使用lambda更有意义？

我知道我的问题是有效的反向时,在仿函数使用lambda,但我不认为在实践中的情况下一个仿函数会首选在拉姆达.有什么想法吗？