Difference between revisions of "Num instance for functions"

From HaskellWiki
Jump to: navigation, search
(BASIC blog post)
(Refurbish very patchy article to contain the essentials)
 
Line 1: Line 1:
Some people have argued, that <hask>Num</hask> instances of <hask>(->)</hask> would be nice in order
 
  +
It is possible to write a <hask>Num</hask> instance for functions in Haskell:
to add functions nicely, say for
 
<haskell>f, g :: Num a => b -> a</haskell>
 
you would define
 
<haskell>(f+g) x = f x + g x</haskell>
 
   
With an according definition of <hask>fromInteger</hask>
 
  +
<haskell>
<haskell>fromInteger = const</haskell>
 
  +
instance Num b => Num (a -> b) where
numeric literals would also denote constant functions. This allows
 
  +
negate = fmap negate
<haskell>f+2 == \x -> f x + 2</haskell>.
 
  +
(+) = liftA2 (+)
  +
(*) = liftA2 (*)
  +
fromInteger = pure . fromInteger
  +
abs = fmap abs
  +
signum = fmap signum
  +
</haskell>
   
Even nicer, the mathematically established notation of omitting the
 
  +
This allows writing expressions of the form
multiplication dot
 
<haskell>2(x+y) :: Integer</haskell>
 
will now be parsed by a Haskell compiler to the most obvious meaning
 
<haskell>2 :: Integer</haskell>
 
! :-)
 
   
== Note ==
 
  +
<haskell>
  +
> (sin^2 + cos^2) 123.4
  +
1.0
  +
</haskell>
   
This article is in category Proposals in order to show people that this idea was already proposed,
 
  +
where functions can be added like <hask>Num</hask>bers, leaving their arguments open for later.
but that one should think twice implementing it.
 
There should be a category Counterproposals.
 
   
  +
The usefulness of this instance is debatable, and it is not currently part of [[Language and library specification|the language report]] or defined in any popular library.
   
 
== See also ==
 
== See also ==
Line 33: Line 31:
   
 
[[Category:Humor]]
 
[[Category:Humor]]
[[Category:Proposals]]
 
 
[[Category:FAQ]]
 
[[Category:FAQ]]
 
[[Category:Style]]
 
[[Category:Style]]

Latest revision as of 01:24, 28 December 2014

It is possible to write a Num instance for functions in Haskell:

instance Num b => Num (a -> b) where
      negate      = fmap negate
      (+)         = liftA2 (+)
      (*)         = liftA2 (*)
      fromInteger = pure . fromInteger
      abs         = fmap abs
      signum      = fmap signum

This allows writing expressions of the form

> (sin^2 + cos^2) 123.4
1.0

where functions can be added like Numbers, leaving their arguments open for later.

The usefulness of this instance is debatable, and it is not currently part of the language report or defined in any popular library.

See also