functor

I'm quite confuse by the behaviour of map(). I have an array of objects like this : const products = [{ ..., 'productType' = 'premium', ... }, ...] and i'm passing this array to a function that should return the same array but with all product made free : [{ ..., 'productType' = 'free', ... }, ...] The function is : const freeProduct = function(products){ return products.map(x => x.productType = "free") } Which returns the following array : ["free", "free", ...] So i rewrote my function to be : const freeProduct = function(products){ return products.map(x => {x.productType = "free"; return x})

Learn You a Haskell has an example about functors. I can read LYAH, and text, and figure out what is supposed to happen -- but I don't know enough to write something like this. I'm finding this problem often in Haskell. instance Functor (Either a) where fmap f (Right x) = Right (f x) fmap f (Left x) = Left x However, I'm confused.. Why doesn't this comple instance Functor (Either a) where fmap f (Right x) = Right (x) fmap f (Left x) = Left (f x) If f isn't being used in the top definition, then what else constrains x such that it can't satisfy Left Here's the functor class: class Functor f

I'm new to Haskell, and I'm reading about functors and applicative functors. Ok, I understand functors and how I can use them, but I don't understand why applicative functors are useful and how I can use them in Haskell. Can you explain to me with a simple example why I need applicative functors? huitseeker Applicative functors are a construction that provides the midpoint between functors and monads , and are therefore more widespread than monads, while more useful than functors. Normally you can just map a function over a functor. Applicative functors allow you to take a "normal" function

Here is a code: #include <functional> using namespace std::tr1; typedef void(*fp)(void); void foo(void) { } void f(fp) { } int main() { function<void(void)> fun = foo; f(fun); // error f(foo); // ok } Originally i need to make a function pointer from non-static class method because i need to save data between function callings. I tried std::tr1::bind and boost::bind , but they return functional object, not pointer, which, as i can see, can't be "casted" to pure functional pointer. While the function signature ( SetupIterateCabinet ) demands a pure func pointer exactly. I need an advise how to

I was messing around with Scala 2.8 for fun and trying to define a pimp which adds an "as" method to type constructors, allowing to convert from one functor to another (please overlook the fact that I'm not necessarily dealing with functors here). So for instance, you could use it like this: val array:Array[T] val list:List[T] = array.as[List] So here's what I tried to do: object Test { abstract class NatTrans[F[_], G[_]] { def convert[T](f:F[T]):G[T] } implicit def array2List:NatTrans[Array, List] = new NatTrans[Array, List] { def convert[T](a:Array[T]) = a.toList } // this next part gets

I have many programs written in OCaml, some of them use functors. Now, I am considering of writing and re-writing a part of code in F# (to benefit some advantages that OCaml does not have). One thing I am afraid of is to write code in F# for what functors do in OCaml. For instance, how could we emulate this example from OCaml manual in F#? type comparison = Less | Equal | Greater module type ORDERED_TYPE = sig type t val compare: t -> t -> comparison end module Set = functor (Elt: ORDERED_TYPE) -> struct type element = Elt.t type set = element list let empty = [] let rec add x s = match s with