Mathematically speaking we have to distinguish the types for forward and for backward methods because the second acts on the cotangent bundle. However, for simplicity and due to technical reasons we identify the types input and dInput as well as output and dOutput which is enough for our purposes because these types are usually real numbers or arrays of real numbers.

>>> import Prelude (fmap, Float)
>>> import InfBackprop (pow, call, derivative)
>>> myFunc = pow 2 :: BackpropFunc Float Float
>>> f = call myFunc :: Float -> Float
>>> fmap f [-3, -2, -1, 0, 1, 2, 3]
[9.0,4.0,1.0,0.0,1.0,4.0,9.0]
>>> df = derivative myFunc :: Float -> Float
>>> fmap df [-3, -2, -1, 0, 1, 2, 3]
[-6.0,-4.0,-2.0,0.0,2.0,4.0,6.0]

>>> import InfBackprop (sin)
>>> import Prelude (Float)
>>> derivative sin (0 :: Float)
1.0

>>> import InfBackprop (pow, const)
>>> import Prelude (Float, fmap)
>>> myFunc = (pow 2) :: Backprop (->) Float Float

>>> fmap (derivativeN 0 myFunc) [-3, -2, -1, 0, 1, 2, 3]
[9.0,4.0,1.0,0.0,1.0,4.0,9.0]

>>> fmap (derivativeN 1 myFunc) [-3, -2, -1, 0, 1, 2, 3]
[-6.0,-4.0,-2.0,0.0,2.0,4.0,6.0]

>>> fmap (derivativeN 2 myFunc) [-3, -2, -1, 0, 1, 2, 3]
[2.0,2.0,2.0,2.0,2.0,2.0,2.0]

>>> fmap (derivativeN 3 myFunc) [-3, -2, -1, 0, 1, 2, 3]
[0.0,0.0,0.0,0.0,0.0,0.0,0.0]

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative, derivativeN)

>>> call (const 5) ()
5

>>> derivative (const (5 :: Float)) 42
0

>>> derivativeN 2 (const (5 :: Float)) 42
0.0

>>> import Prelude (fmap, Float)
>>> import InfBackprop (pow, call, derivative)
>>> myFunc = linear 2 :: BackpropFunc Float Float

>>> f = call myFunc :: Float -> Float
>>> fmap f [-3, -2, -1, 0, 1, 2, 3]
[-6.0,-4.0,-2.0,0.0,2.0,4.0,6.0]

>>> df = derivative myFunc :: Float -> Float
>>> fmap df [-3, -2, -1, 0, 1, 2, 3]
[2.0,2.0,2.0,2.0,2.0,2.0,2.0]

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)

>>> call (+) (2, 3) :: Float
5.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> y = variable "y"
>>> derivative (+) (x, y)
(1,1)

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)

>>> call (-) (5, 3) :: Float
2.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> y = variable "y"
>>> derivative (-) (x, y)
(1,-(1))

>>> import Prelude (Float, ($))
>>> import InfBackprop (call, derivative)

>>> call negate 42 :: Float
-42.0

>>> derivative negate 42 :: Float
-1.0

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call (*) (2, 3) :: Float
6.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> y = variable "y"
>>> derivative (*) (x, y)
(1·y,1·x)

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call (/) (6, 3) :: Float
2.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> y = variable "y"
>>> derivative (/) (x, y)
(1·(1/y),1·(-(x)·(1/(y·y))))

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call dup (42.0 :: Float)
(42.0,42.0)

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> derivative (dup >>> (*)) x
(1·x)+(1·x)

>>> import InfBackprop (call, derivative)

>>> f = first forget >>> (iso :: BackpropFunc ((), a) a) :: Additive a => BackpropFunc (a, a) a

>>> call f (24, 42)
42

>>> derivative f (24, 42)
(0,1)

>>> import InfBackprop (call, derivative)

>>> call forgetFirst (24, 42)
42

>>> derivative forgetFirst (24, 42)
(0,1)

>>> import InfBackprop (call, derivative)

>>> call forgetSecond (24, 42)
24

>>> derivative forgetSecond (24, 42)
(1,0)

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call log 10 :: Float
2.3025851

>>> derivative log 10 :: Float
0.1

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call logBase (2, 8) :: Float
3.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> n = variable "n"
>>> derivative logBase (n, x)
((1·(-(log(x))·(1/(log(n)·log(n)))))·(1/n),(1·(1/log(n)))·(1/x))

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call exp 2
7.38905609893065

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> derivative exp x
1·exp(x)

>>> import Prelude (Float)
>>> import NumHask (half)
>>> import InfBackprop (call, derivative)
>>> call (**) (0.5, 9) :: Float
3.0

>>> import Debug.SimpleExpr.Expr (variable)
>>> x = variable "x"
>>> n = variable "n"
>>> derivative (**) (n, x)
(1·(n·(x^(n-1))),1·((x^n)·log(x)))

>>> import Prelude (Float)
>>> import InfBackprop (call, derivative)
>>> call (pow 3) 2 :: Float
8.0

>>> derivative (pow 3) 2 :: Float
12.0

>>> import Control.Arrow (runKleisli)
>>> import Control.Monad.Logger (runStdoutLoggingT)
>>> import Debug.SimpleExpr.Expr (variable)
>>> import InfBackprop (call, derivative, backpropExpr)

>>> x = variable "x"
>>> f = backpropExpr "f"
>>> call f x
f(x)

>>> derivative f x
1·f'(x)

>>> import Control.Arrow (runKleisli)
>>> import Control.Monad.Logger (runStdoutLoggingT)
>>> import Debug.SimpleExpr.Expr (variable)
>>> import InfBackprop (call, derivative)

>>> x = variable "x"
>>> f = loggingBackpropExpr "f"
>>> runStdoutLoggingT $ runKleisli (call f) x
[Info] Calculating f of x => f(x)
f(x)

>>> runStdoutLoggingT $ runKleisli (derivative f) x
[Info] Calculating f of x => f(x)
[Info] Calculating f' of x => f'(x)
[Info] Calculating multiplication of 1 and f'(x) => 1·f'(x)
1·f'(x)

>>> import Control.Arrow (runKleisli)
>>> import Control.Monad.Logger (runStdoutLoggingT)

>>> loggingDup = pureKleisli (\x -> (x, x))
>>> runStdoutLoggingT $ runKleisli loggingDup 42
(42,42)

>>> import qualified NumHask as NH
>>> cos = simpleDifferentiable NH.cos (sin >>> negate)