2app_id_maybe :: (forall a. a -> Maybe a) -> (b,c) -> (Maybe b,Maybe c)
2app_id_maybe f (x, y) = (f x, f y)

2app_maybe_id :: (forall a. Maybe a -> a) -> (Maybe b,Maybe c) -> (b,c)
2app_maybe_id f (x, y) = (f x, f y)

2app_id_list :: (forall a. a -> [a]) -> (b, c) -> ([b], [c])
2app_id_list f (x, y) = (f x, f y)

2app_id_listlist :: (forall a. a -> [[a]]) -> (b, c) -> ([[b]], [[c]])
2app_id_listlist f (x, y) = (f x, f y)

2app_list_id :: (forall a. [a] -> a) -> ([b], [c]) -> (b, c)
2app_list_id f (x, y) = (f x, f y)

Well, since their code are textually identical one should obviously
unify them:

2app f (x, y) = (f x, f y)

But what type does it have?  The inferred type is:

2app :: (a -> b) -> (a, a) -> (b, b)

But that isn't general enough, so I want to annotate the type.  I can't
figure out how to express it.  I tried the following, but it didn't even
parse:

app2 :: (tf1 :: * -> *, tf2 :: * -> *) => (forall a. tf1 a -> tf2 a) ->
(tf1 b, tf1 c) -> (tf2 b, tf2 c)

tf1 and tf2 are "type functions" of kind * -> *, more general than just
type constructors of type * -> *.

---

The worst bit is that this function is trivial to write in
dynamically-typed languages:

(define (app2 f x) (cons (f (car x) (cdr x))))

def app2(f, x):
   y, z = x
   return f(y), f(z)