Is there a macro-based adapter to make a functor from a class?

Does that help How about boost::function_output_iterator?

I hope this helps you . One possibility is to encode the "Container" type using another associated type.

import qualified Data.Map.Lazy as M

class MyMap m where
  type Key m
  type Value m
  type Container m :: * -> *
  keys :: m -> [Key m]
  elems :: m -> [Value m]
  mapify :: (a -> b) -> Container m a -> Container m b

instance MyMap (M.Map k v) where
  type Key (M.Map k v) = k
  type Value (M.Map k v) = v
  type Container (M.Map k v) = M.Map k
  keys = M.keys
  elems = M.elems
  mapify = M.map

class MyMap m where
  type Key m
  type Value m
  type Container m :: * -> *
  keys :: m -> [Key m]
  elems :: m -> [Value m]
  -- mapify :: (a -> b) -> Container m a -> Container m b

  -- Make sure the type-checker knows that m2 is just the container of m with
  -- a different value
  mapify :: (MyMap m2, m2 ~ Container m (Value m2)) => (Value m -> Value m2) -> m -> m2


instance MyMap (M.Map k v) where
  type Key (M.Map k v) = k
  type Value (M.Map k v) = v
  type Container (M.Map k v) = M.Map k
  keys = M.keys
  elems = M.elems
  mapify = M.map

doSomething
  :: (MyMap m1, MyMap m2, m2 ~ Container m1 (Value m2)) =>
     (Value m1 -> Value m2) -> m1 -> m2
doSomething f m = mapify f m

should help you out For an empty object, just create it in the stack. Adding the functor to your type as a member will make all of your objects larger. Adding it as a base (to make use of the empty base optimization), will yield a weird design in which your type implements operator()(const MyData&) for no reason. Even if you make it private the operator will be there.
Since the type has no members, there is no cache locality issues, as no data to be accessed. The main use of a stateless functor is to allow the compiler to inline the call to the function (compared with a free function with the same name)

Hope this helps You've overspecialized.
The definition of a functor is as follows:

class Functor f where
    fmap :: (a -> b) -> f a -> f b