In den Kommentaren der FrageStillschweigende Funktionszusammensetzung in HaskellDie Leute erwähnten, wie man eineNum Instanz füra -> rAlso dachte ich, ich würde mit der Funktionsnotation spielen, um die Multiplikation darzustellen:

{-# LANGUAGE TypeFamilies #-}
import Control.Applicative

instance Show (a->r) where   -- not needed in recent GHC versions
  show f = " a function "

instance Eq (a->r) where     -- not needed in recent GHC versions
  f == g = error "sorry, Haskell, I lied, I can't really compare functions for equality"

instance (Num r,a~r) => Num (a -> r) where
  (+) = liftA2 (+)
  (-) = liftA2 (-)
  (*) = liftA2 (*)
  abs = liftA abs
  negate = liftA negate
  signum = liftA signum
  fromInteger a = (fromInteger a *)

Beachten Sie, dass die fromInteger-Definition bedeutet, dass ich schreiben kann3 4 was 12 ergibt, und7 (2+8) ist 70, genau wie du es dir erhoffen würdest.

Dann geht alles wunderbar, unterhaltsam komisch! Bitte erkläre diese Seltsamkeit, wenn du kannst:

*Main> 1 2 3
18
*Main> 1 2 4
32
*Main> 1 2 5
50
*Main> 2 2 3
36
*Main> 2 2 4
64
*Main> 2 2 5
100
*Main> (2 3) (5 2)
600

[Bearbeiten: Verwendet Applicative anstelle von Monad, weil Applicative im Allgemeinen großartig ist, aber es macht keinen großen Unterschied zum Code.]