Nos, technikailag épp elég IncoherentInstances segítségével szinte bármit megtehet:

{-# LANGUAGE MultiParamTypeClasses, TypeFamilies,
  FlexibleInstances, UndecidableInstances, IncoherentInstances #-}

class Augment a b f h where
   augment :: (a -> b) -> f -> h

instance (a ~ c, h ~ b) => Augment a b c h where
   augment = ($)

instance (Augment a b d h', h ~ (c -> h')) => Augment a b (c -> d) h where
   augment g f = augment g . f

-- Usage
t1 = augment not not
r1 = t1 True

t2 = augment (+1) (+)
r2 = t2 2 3

t3 = augment (+1) foldr
r3 = t3 (+) 0 [2,3]

Valahogy megteheti, de mivel nem lehet viselkedést megadni mindenre, ami nem függvény, sok triviális példányra lesz szüksége az összes többi fontos típushoz. ról ről.

{-# LANGUAGE TypeFamilies, DefaultSignatures #-}

class Augment a where
  type Result a
  type Result a = a

  type Augmented a r
  type Augmented a r = r

  augment :: (Result a -> r) -> a -> Augmented a r

  default augment :: (a -> r) -> a -> r
  augment g x = g x

instance Augment b => Augment (a -> b) where
  type Result (a -> b) = Result b
  type Augmented (a -> b) r = a -> Augmented b r

  augment g f x = augment g (f x) 

instance Augment Bool
instance Augment Char
instance Augment Integer
instance Augment [a]

-- and so on for every result type of every function you want to augment...

Példa:

> let g n x ys = replicate n x ++ ys
> g 2 'a' "bc"
"aabc"
> let g' = augment length g
> g' 2 'a' "bc"
4
> :t g
g :: Int -> a -> [a] -> [a]
> :t g'
g' :: Int -> a -> [a] -> Int

A probléma az, hogy a a -> b -> c-hez hasonló dolgok valós visszatérési értéke nem c, hanem b -> c. Amit szeretne, valamilyen tesztre van szükség, amely megmondja, hogy egy típus nem függvénytípus. Felsorolhatnád azokat a típusokat, amelyek érdekelnek, de ez nem olyan szép. Szerintem HList oldja meg valahogy ezt a problémát, nézze meg a papírt. Sikerült egy kicsit megértenem a megoldást az átfedő esetekkel, de a többi kicsit átmegy a fejemen, attól tartok.

A JavaScript működik, mert argumentumai sorozatok vagy listák, tehát valójában csak egy argumentum van. Ebben az értelemben ez ugyanaz, mint a függvények curryed változata, amelyben az argumentumok gyűjteményét reprezentáló sor.

Egy erősen begépelt nyelvben sokkal több információra van szükség ahhoz, hogy ezt "átláthatóan" megtegye egy függvénytípus esetében – például a függő típusok kifejezhetik ezt az elképzelést, de megkövetelik, hogy a függvények meghatározott típusúak legyenek, nem tetszőleges függvénytípusok.

Azt hiszem, láttam egy megoldást a Haskellben, amely ezt is meg tudja tenni, de ismét csak bizonyos típusoknál működik, amelyek a függvény valódiságát rögzítik, nem bármely függvényt.