{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

-- |
-- Module      : Numeric.Backprop.Class
-- Copyright   : (c) Justin Le 2023
-- License     : BSD3
--
-- Maintainer  : justin@jle.im
-- Stability   : experimental
-- Portability : non-portable
--
-- Provides the 'Backprop' typeclass, a class for values that can be used
-- for backpropagation.
--
-- This class replaces the old (version 0.1) API relying on 'Num'.
--
-- @since 0.2.0.0
module Numeric.Backprop.Class (
  -- * Backpropagatable types
  Backprop (..),

  -- * Derived methods
  zeroNum,
  addNum,
  oneNum,
  zeroVec,
  addVec,
  oneVec,
  zeroVecNum,
  oneVecNum,
  zeroFunctor,
  addIsList,
  addAsList,
  oneFunctor,
  genericZero,
  genericAdd,
  genericOne,

  -- * Newtype
  ABP (..),
  NumBP (..),
  NumVec (..),

  -- * Generics
  GZero,
  GAdd,
  GOne,
) where

import Control.Applicative
import qualified Control.Arrow as Arr
import Control.DeepSeq
import Control.Monad
import Data.Coerce
import Data.Complex
import Data.Data
import Data.Functor.Compose
import Data.Functor.Identity
import qualified Data.Functor.Product as DFP
import qualified Data.IntMap as IM
import Data.List.NonEmpty (NonEmpty (..))
import qualified Data.Map as M
import Data.Monoid
import Data.Ratio
import qualified Data.Semigroup as SG
import qualified Data.Sequence as Seq
import qualified Data.Vector as V
import qualified Data.Vector.Generic as VG
import qualified Data.Vector.Primitive as VP
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Unboxed as VU
import Data.Vinyl
import Data.Vinyl.ARec
import qualified Data.Vinyl.Functor as V
import Data.Vinyl.TypeLevel
import qualified Data.Vinyl.XRec as V
import Data.Void
import Data.Word
import GHC.Exts
import GHC.Generics
import Numeric.Natural

-- | Class of values that can be backpropagated in general.
--
-- For instances of 'Num', these methods can be given by 'zeroNum',
-- 'addNum', and 'oneNum'.  There are also generic options given in
-- "Numeric.Backprop.Class" for functors, 'IsList' instances, and 'Generic'
-- instances.
--
-- @
-- instance 'Backprop' 'Double' where
--     'zero' = 'zeroNum'
--     'add' = 'addNum'
--     'one' = 'oneNum'
-- @
--
-- If you leave the body of an instance declaration blank, GHC Generics
-- will be used to derive instances if the type has a single constructor
-- and each field is an instance of 'Backprop'.
--
-- To ensure that backpropagation works in a sound way, should obey the
-- laws:
--
-- [/identity/]
--
--   * @'add' x ('zero' y) = x@
--
--   * @'add' ('zero' x) y = y@
--
-- Also implies preservation of information, making @'zipWith' ('+')@ an
-- illegal implementation for lists and vectors.
--
-- This is only expected to be true up to potential "extra zeroes" in @x@
-- and @y@ in the result.
--
-- [/commutativity/]
--
--   * @'add' x y = 'add' y x@
--
-- [/associativity/]
--
--   * @'add' x ('add' y z) = 'add' ('add' x y) z@
--
-- [/idempotence/]
--
--   * @'zero' '.' 'zero' = 'zero'@
--
--   * @'one' '.' 'one' = 'one'@
--
-- [/unital/]
--
--   * @'one' = 'gradBP' 'id'@
--
-- Note that not all values in the backpropagation process needs all of
-- these methods: Only the "final result" needs 'one', for example.  These
-- are all grouped under one typeclass for convenience in defining
-- instances, and also to talk about sensible laws.  For fine-grained
-- control, use the "explicit" versions of library functions (for example,
-- in "Numeric.Backprop.Explicit") instead of 'Backprop' based ones.
--
-- This typeclass replaces the reliance on 'Num' of the previous API
-- (v0.1).  'Num' is strictly more powerful than 'Backprop', and is
-- a stronger constraint on types than is necessary for proper
-- backpropagating.  In particular, 'fromInteger' is a problem for many
-- types, preventing useful backpropagation for lists, variable-length
-- vectors (like "Data.Vector") and variable-size matrices from linear
-- algebra libraries like /hmatrix/ and /accelerate/.
--
-- @since 0.2.0.0
class Backprop a where
  -- | "Zero out" all components of a value.  For scalar values, this
  -- should just be @'const' 0@.  For vectors and matrices, this should
  -- set all components to zero, the additive identity.
  --
  -- Should be idempotent:
  --
  --   * @'zero' '.' 'zero' = 'zero'@
  --
  -- Should be as /lazy/ as possible.  This behavior is observed for
  -- all instances provided by this library.
  --
  -- See 'zeroNum' for a pre-built definition for instances of 'Num' and
  -- 'zeroFunctor' for a definition for instances of 'Functor'.  If left
  -- blank, will automatically be 'genericZero', a pre-built definition
  -- for instances of 'GHC.Generic' whose fields are all themselves
  -- instances of 'Backprop'.
  zero :: a -> a

  -- | Add together two values of a type.  To combine contributions of
  -- gradients, so should be information-preserving:
  --
  --   * @'add' x ('zero' y) = x@
  --
  --   * @'add' ('zero' x) y = y@
  --
  -- Should be as /strict/ as possible.  This behavior is observed for
  -- all instances provided by this library.
  --
  -- See 'addNum' for a pre-built definition for instances of 'Num' and
  -- 'addIsList' for a definition for instances of 'IsList'.  If left
  -- blank, will automatically be 'genericAdd', a pre-built definition
  -- for instances of 'GHC.Generic' with one constructor whose fields are
  -- all themselves instances of 'Backprop'.
  add :: a -> a -> a

  -- | "One" all components of a value.  For scalar values, this should
  -- just be @'const' 1@.  For vectors and matrices, this should set all
  -- components to one, the multiplicative identity.
  --
  -- As the library uses it, the most important law is:
  --
  --   * @'one' = 'gradBP' 'id'@
  --
  -- That is, @'one' x@ is the gradient of the identity function with
  -- respect to its input.
  --
  -- Ideally should be idempotent:
  --
  --   * @'one' '.' 'one' = 'one'@
  --
  -- Should be as /lazy/ as possible.  This behavior is observed for
  -- all instances provided by this library.
  --
  -- See 'oneNum' for a pre-built definition for instances of 'Num' and
  -- 'oneFunctor' for a definition for instances of 'Functor'.  If left
  -- blank, will automatically be 'genericOne', a pre-built definition
  -- for instances of 'GHC.Generic' whose fields are all themselves
  -- instances of 'Backprop'.
  one :: a -> a

  default zero :: (Generic a, GZero (Rep a)) => a -> a
  zero = a -> a
forall a. (Generic a, GZero (Rep a)) => a -> a
genericZero
  {-# INLINE zero #-}
  default add :: (Generic a, GAdd (Rep a)) => a -> a -> a
  add = a -> a -> a
forall a. (Generic a, GAdd (Rep a)) => a -> a -> a
genericAdd
  {-# INLINE add #-}
  default one :: (Generic a, GOne (Rep a)) => a -> a
  one = a -> a
forall a. (Generic a, GOne (Rep a)) => a -> a
genericOne
  {-# INLINE one #-}

-- | 'zero' using GHC Generics; works if all fields are instances of
-- 'Backprop'.
genericZero :: (Generic a, GZero (Rep a)) => a -> a
genericZero :: forall a. (Generic a, GZero (Rep a)) => a -> a
genericZero = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to (Rep a Any -> a) -> (a -> Rep a Any) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> Rep a Any
forall t. Rep a t -> Rep a t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero (Rep a Any -> Rep a Any) -> (a -> Rep a Any) -> a -> Rep a Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from
{-# INLINE genericZero #-}

-- | 'add' using GHC Generics; works if all fields are instances of
-- 'Backprop', but only for values with single constructors.
genericAdd :: (Generic a, GAdd (Rep a)) => a -> a -> a
genericAdd :: forall a. (Generic a, GAdd (Rep a)) => a -> a -> a
genericAdd a
x a
y = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to (Rep a Any -> a) -> Rep a Any -> a
forall a b. (a -> b) -> a -> b
$ Rep a Any -> Rep a Any -> Rep a Any
forall t. Rep a t -> Rep a t -> Rep a t
forall (f :: * -> *) t. GAdd f => f t -> f t -> f t
gadd (a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
x) (a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
y)
{-# INLINE genericAdd #-}

-- | 'one' using GHC Generics; works if all fields are instaces of
-- 'Backprop'.
genericOne :: (Generic a, GOne (Rep a)) => a -> a
genericOne :: forall a. (Generic a, GOne (Rep a)) => a -> a
genericOne = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to (Rep a Any -> a) -> (a -> Rep a Any) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> Rep a Any
forall t. Rep a t -> Rep a t
forall (f :: * -> *) t. GOne f => f t -> f t
gone (Rep a Any -> Rep a Any) -> (a -> Rep a Any) -> a -> Rep a Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from
{-# INLINE genericOne #-}

-- | 'zero' for instances of 'Num'.
--
-- Is lazy in its argument.
zeroNum :: Num a => a -> a
zeroNum :: forall a. Num a => a -> a
zeroNum a
_ = a
0
{-# INLINE zeroNum #-}

-- | 'add' for instances of 'Num'.
addNum :: Num a => a -> a -> a
addNum :: forall a. Num a => a -> a -> a
addNum = a -> a -> a
forall a. Num a => a -> a -> a
(+)
{-# INLINE addNum #-}

-- | 'one' for instances of 'Num'.
--
-- Is lazy in its argument.
oneNum :: Num a => a -> a
oneNum :: forall a. Num a => a -> a
oneNum a
_ = a
1
{-# INLINE oneNum #-}

-- | 'zero' for instances of 'VG.Vector'.
zeroVec :: (VG.Vector v a, Backprop a) => v a -> v a
zeroVec :: forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
zeroVec = (a -> a) -> v a -> v a
forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b) -> v a -> v b
VG.map a -> a
forall a. Backprop a => a -> a
zero
{-# INLINE zeroVec #-}

-- | 'add' for instances of 'VG.Vector'.  Automatically pads the end of the
-- shorter vector with zeroes.
addVec :: (VG.Vector v a, Backprop a) => v a -> v a -> v a
addVec :: forall (v :: * -> *) a.
(Vector v a, Backprop a) =>
v a -> v a -> v a
addVec v a
x v a
y = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
lX Int
lY of
  Ordering
LT ->
    let (v a
y1, v a
y2) = Int -> v a -> (v a, v a)
forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
VG.splitAt (Int
lY Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lX) v a
y
     in (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Backprop a => a -> a -> a
add v a
x v a
y1 v a -> v a -> v a
forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
VG.++ v a
y2
  Ordering
EQ -> (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Backprop a => a -> a -> a
add v a
x v a
y
  Ordering
GT ->
    let (v a
x1, v a
x2) = Int -> v a -> (v a, v a)
forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
VG.splitAt (Int
lX Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lY) v a
x
     in (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Backprop a => a -> a -> a
add v a
x1 v a
y v a -> v a -> v a
forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
VG.++ v a
x2
  where
    lX :: Int
lX = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length v a
x
    lY :: Int
lY = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length v a
y

-- | 'one' for instances of 'VG.Vector'.
oneVec :: (VG.Vector v a, Backprop a) => v a -> v a
oneVec :: forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
oneVec = (a -> a) -> v a -> v a
forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b) -> v a -> v b
VG.map a -> a
forall a. Backprop a => a -> a
one
{-# INLINE oneVec #-}

-- | 'zero' for instances of 'VG.Vector' when the contained type is an
-- instance of 'Num'.  Is potentially more performant than 'zeroVec' when
-- the vectors are larger.
--
-- See 'NumVec' for a 'Backprop' instance for 'VG.Vector' instances that
-- uses this for 'zero'.
--
-- @since 0.2.4.0
zeroVecNum :: (VG.Vector v a, Num a) => v a -> v a
zeroVecNum :: forall (v :: * -> *) a. (Vector v a, Num a) => v a -> v a
zeroVecNum = (Int -> a -> v a) -> a -> Int -> v a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> a -> v a
forall (v :: * -> *) a. Vector v a => Int -> a -> v a
VG.replicate a
0 (Int -> v a) -> (v a -> Int) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length
{-# INLINE zeroVecNum #-}

-- | 'one' for instances of 'VG.Vector' when the contained type is an
-- instance of 'Num'.  Is potentially more performant than 'oneVec' when
-- the vectors are larger.
--
-- See 'NumVec' for a 'Backprop' instance for 'VG.Vector' instances that
-- uses this for 'one'.
--
-- @since 0.2.4.0
oneVecNum :: (VG.Vector v a, Num a) => v a -> v a
oneVecNum :: forall (v :: * -> *) a. (Vector v a, Num a) => v a -> v a
oneVecNum = (Int -> a -> v a) -> a -> Int -> v a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> a -> v a
forall (v :: * -> *) a. Vector v a => Int -> a -> v a
VG.replicate a
1 (Int -> v a) -> (v a -> Int) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length
{-# INLINE oneVecNum #-}

-- | 'zero' for 'Functor' instances.
zeroFunctor :: (Functor f, Backprop a) => f a -> f a
zeroFunctor :: forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor = (a -> a) -> f a -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Backprop a => a -> a
zero
{-# INLINE zeroFunctor #-}

-- | 'add' for instances of 'IsList'.  Automatically pads the end of the
-- "shorter" value with zeroes.
addIsList :: (IsList a, Backprop (Item a)) => a -> a -> a
addIsList :: forall a. (IsList a, Backprop (Item a)) => a -> a -> a
addIsList = (a -> [Item a]) -> ([Item a] -> a) -> a -> a -> a
forall b a. Backprop b => (a -> [b]) -> ([b] -> a) -> a -> a -> a
addAsList a -> [Item a]
forall l. IsList l => l -> [Item l]
toList [Item a] -> a
forall l. IsList l => [Item l] -> l
fromList
{-# INLINE addIsList #-}

-- | 'add' for types that are isomorphic to a list.
-- Automatically pads the end of the "shorter" value with zeroes.
addAsList ::
  Backprop b =>
  -- | convert to list (should form isomorphism)
  (a -> [b]) ->
  -- | convert from list (should form isomorphism)
  ([b] -> a) ->
  a ->
  a ->
  a
addAsList :: forall b a. Backprop b => (a -> [b]) -> ([b] -> a) -> a -> a -> a
addAsList a -> [b]
f [b] -> a
g a
x a
y = [b] -> a
g ([b] -> a) -> [b] -> a
forall a b. (a -> b) -> a -> b
$ [b] -> [b] -> [b]
go (a -> [b]
f a
x) (a -> [b]
f a
y)
  where
    go :: [b] -> [b] -> [b]
go = \case
      [] -> [b] -> [b]
forall a. a -> a
id
      o :: [b]
o@(b
x' : [b]
xs) -> \case
        [] -> [b]
o
        b
y' : [b]
ys -> b -> b -> b
forall a. Backprop a => a -> a -> a
add b
x' b
y' b -> [b] -> [b]
forall a. a -> [a] -> [a]
: [b] -> [b] -> [b]
go [b]
xs [b]
ys

-- | 'one' for instances of 'Functor'.
oneFunctor :: (Functor f, Backprop a) => f a -> f a
oneFunctor :: forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor = (a -> a) -> f a -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Backprop a => a -> a
one
{-# INLINE oneFunctor #-}

-- | A newtype wrapper over an instance of 'Num' that gives a free
-- 'Backprop' instance.
--
-- Useful for things like /DerivingVia/, or for avoiding orphan instances.
--
-- @since 0.2.1.0
newtype NumBP a = NumBP {forall a. NumBP a -> a
runNumBP :: a}
  deriving
    ( Int -> NumBP a -> ShowS
[NumBP a] -> ShowS
NumBP a -> String
(Int -> NumBP a -> ShowS)
-> (NumBP a -> String) -> ([NumBP a] -> ShowS) -> Show (NumBP a)
forall a. Show a => Int -> NumBP a -> ShowS
forall a. Show a => [NumBP a] -> ShowS
forall a. Show a => NumBP a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> NumBP a -> ShowS
showsPrec :: Int -> NumBP a -> ShowS
$cshow :: forall a. Show a => NumBP a -> String
show :: NumBP a -> String
$cshowList :: forall a. Show a => [NumBP a] -> ShowS
showList :: [NumBP a] -> ShowS
Show
    , ReadPrec [NumBP a]
ReadPrec (NumBP a)
Int -> ReadS (NumBP a)
ReadS [NumBP a]
(Int -> ReadS (NumBP a))
-> ReadS [NumBP a]
-> ReadPrec (NumBP a)
-> ReadPrec [NumBP a]
-> Read (NumBP a)
forall a. Read a => ReadPrec [NumBP a]
forall a. Read a => ReadPrec (NumBP a)
forall a. Read a => Int -> ReadS (NumBP a)
forall a. Read a => ReadS [NumBP a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (NumBP a)
readsPrec :: Int -> ReadS (NumBP a)
$creadList :: forall a. Read a => ReadS [NumBP a]
readList :: ReadS [NumBP a]
$creadPrec :: forall a. Read a => ReadPrec (NumBP a)
readPrec :: ReadPrec (NumBP a)
$creadListPrec :: forall a. Read a => ReadPrec [NumBP a]
readListPrec :: ReadPrec [NumBP a]
Read
    , NumBP a -> NumBP a -> Bool
(NumBP a -> NumBP a -> Bool)
-> (NumBP a -> NumBP a -> Bool) -> Eq (NumBP a)
forall a. Eq a => NumBP a -> NumBP a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NumBP a -> NumBP a -> Bool
== :: NumBP a -> NumBP a -> Bool
$c/= :: forall a. Eq a => NumBP a -> NumBP a -> Bool
/= :: NumBP a -> NumBP a -> Bool
Eq
    , Eq (NumBP a)
Eq (NumBP a) =>
(NumBP a -> NumBP a -> Ordering)
-> (NumBP a -> NumBP a -> Bool)
-> (NumBP a -> NumBP a -> Bool)
-> (NumBP a -> NumBP a -> Bool)
-> (NumBP a -> NumBP a -> Bool)
-> (NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a -> NumBP a)
-> Ord (NumBP a)
NumBP a -> NumBP a -> Bool
NumBP a -> NumBP a -> Ordering
NumBP a -> NumBP a -> NumBP a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (NumBP a)
forall a. Ord a => NumBP a -> NumBP a -> Bool
forall a. Ord a => NumBP a -> NumBP a -> Ordering
forall a. Ord a => NumBP a -> NumBP a -> NumBP a
$ccompare :: forall a. Ord a => NumBP a -> NumBP a -> Ordering
compare :: NumBP a -> NumBP a -> Ordering
$c< :: forall a. Ord a => NumBP a -> NumBP a -> Bool
< :: NumBP a -> NumBP a -> Bool
$c<= :: forall a. Ord a => NumBP a -> NumBP a -> Bool
<= :: NumBP a -> NumBP a -> Bool
$c> :: forall a. Ord a => NumBP a -> NumBP a -> Bool
> :: NumBP a -> NumBP a -> Bool
$c>= :: forall a. Ord a => NumBP a -> NumBP a -> Bool
>= :: NumBP a -> NumBP a -> Bool
$cmax :: forall a. Ord a => NumBP a -> NumBP a -> NumBP a
max :: NumBP a -> NumBP a -> NumBP a
$cmin :: forall a. Ord a => NumBP a -> NumBP a -> NumBP a
min :: NumBP a -> NumBP a -> NumBP a
Ord
    , Typeable
    , Typeable (NumBP a)
Typeable (NumBP a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NumBP a -> c (NumBP a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NumBP a))
-> (NumBP a -> Constr)
-> (NumBP a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NumBP a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NumBP a)))
-> ((forall b. Data b => b -> b) -> NumBP a -> NumBP a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumBP a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumBP a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NumBP a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NumBP a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a))
-> Data (NumBP a)
NumBP a -> Constr
NumBP a -> DataType
(forall b. Data b => b -> b) -> NumBP a -> NumBP a
forall a. Data a => Typeable (NumBP a)
forall a. Data a => NumBP a -> Constr
forall a. Data a => NumBP a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> NumBP a -> NumBP a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NumBP a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> NumBP a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumBP a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumBP a -> c (NumBP a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NumBP a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NumBP a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NumBP a -> u
forall u. (forall d. Data d => d -> u) -> NumBP a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumBP a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumBP a -> c (NumBP a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NumBP a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NumBP a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumBP a -> c (NumBP a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumBP a -> c (NumBP a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumBP a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumBP a)
$ctoConstr :: forall a. Data a => NumBP a -> Constr
toConstr :: NumBP a -> Constr
$cdataTypeOf :: forall a. Data a => NumBP a -> DataType
dataTypeOf :: NumBP a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NumBP a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NumBP a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NumBP a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NumBP a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> NumBP a -> NumBP a
gmapT :: (forall b. Data b => b -> b) -> NumBP a -> NumBP a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumBP a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> NumBP a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NumBP a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NumBP a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NumBP a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumBP a -> m (NumBP a)
Data
    , (forall x. NumBP a -> Rep (NumBP a) x)
-> (forall x. Rep (NumBP a) x -> NumBP a) -> Generic (NumBP a)
forall x. Rep (NumBP a) x -> NumBP a
forall x. NumBP a -> Rep (NumBP a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (NumBP a) x -> NumBP a
forall a x. NumBP a -> Rep (NumBP a) x
$cfrom :: forall a x. NumBP a -> Rep (NumBP a) x
from :: forall x. NumBP a -> Rep (NumBP a) x
$cto :: forall a x. Rep (NumBP a) x -> NumBP a
to :: forall x. Rep (NumBP a) x -> NumBP a
Generic
    , (forall a b. (a -> b) -> NumBP a -> NumBP b)
-> (forall a b. a -> NumBP b -> NumBP a) -> Functor NumBP
forall a b. a -> NumBP b -> NumBP a
forall a b. (a -> b) -> NumBP a -> NumBP b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NumBP a -> NumBP b
fmap :: forall a b. (a -> b) -> NumBP a -> NumBP b
$c<$ :: forall a b. a -> NumBP b -> NumBP a
<$ :: forall a b. a -> NumBP b -> NumBP a
Functor
    , (forall m. Monoid m => NumBP m -> m)
-> (forall m a. Monoid m => (a -> m) -> NumBP a -> m)
-> (forall m a. Monoid m => (a -> m) -> NumBP a -> m)
-> (forall a b. (a -> b -> b) -> b -> NumBP a -> b)
-> (forall a b. (a -> b -> b) -> b -> NumBP a -> b)
-> (forall b a. (b -> a -> b) -> b -> NumBP a -> b)
-> (forall b a. (b -> a -> b) -> b -> NumBP a -> b)
-> (forall a. (a -> a -> a) -> NumBP a -> a)
-> (forall a. (a -> a -> a) -> NumBP a -> a)
-> (forall a. NumBP a -> [a])
-> (forall a. NumBP a -> Bool)
-> (forall a. NumBP a -> Int)
-> (forall a. Eq a => a -> NumBP a -> Bool)
-> (forall a. Ord a => NumBP a -> a)
-> (forall a. Ord a => NumBP a -> a)
-> (forall a. Num a => NumBP a -> a)
-> (forall a. Num a => NumBP a -> a)
-> Foldable NumBP
forall a. Eq a => a -> NumBP a -> Bool
forall a. Num a => NumBP a -> a
forall a. Ord a => NumBP a -> a
forall m. Monoid m => NumBP m -> m
forall a. NumBP a -> Bool
forall a. NumBP a -> Int
forall a. NumBP a -> [a]
forall a. (a -> a -> a) -> NumBP a -> a
forall m a. Monoid m => (a -> m) -> NumBP a -> m
forall b a. (b -> a -> b) -> b -> NumBP a -> b
forall a b. (a -> b -> b) -> b -> NumBP a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => NumBP m -> m
fold :: forall m. Monoid m => NumBP m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NumBP a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NumBP a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NumBP a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NumBP a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NumBP a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NumBP a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NumBP a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NumBP a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NumBP a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NumBP a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NumBP a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NumBP a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NumBP a -> a
foldr1 :: forall a. (a -> a -> a) -> NumBP a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NumBP a -> a
foldl1 :: forall a. (a -> a -> a) -> NumBP a -> a
$ctoList :: forall a. NumBP a -> [a]
toList :: forall a. NumBP a -> [a]
$cnull :: forall a. NumBP a -> Bool
null :: forall a. NumBP a -> Bool
$clength :: forall a. NumBP a -> Int
length :: forall a. NumBP a -> Int
$celem :: forall a. Eq a => a -> NumBP a -> Bool
elem :: forall a. Eq a => a -> NumBP a -> Bool
$cmaximum :: forall a. Ord a => NumBP a -> a
maximum :: forall a. Ord a => NumBP a -> a
$cminimum :: forall a. Ord a => NumBP a -> a
minimum :: forall a. Ord a => NumBP a -> a
$csum :: forall a. Num a => NumBP a -> a
sum :: forall a. Num a => NumBP a -> a
$cproduct :: forall a. Num a => NumBP a -> a
product :: forall a. Num a => NumBP a -> a
Foldable
    , Functor NumBP
Foldable NumBP
(Functor NumBP, Foldable NumBP) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NumBP a -> f (NumBP b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NumBP (f a) -> f (NumBP a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NumBP a -> m (NumBP b))
-> (forall (m :: * -> *) a. Monad m => NumBP (m a) -> m (NumBP a))
-> Traversable NumBP
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => NumBP (m a) -> m (NumBP a)
forall (f :: * -> *) a. Applicative f => NumBP (f a) -> f (NumBP a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NumBP a -> m (NumBP b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NumBP a -> f (NumBP b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NumBP a -> f (NumBP b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NumBP a -> f (NumBP b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => NumBP (f a) -> f (NumBP a)
sequenceA :: forall (f :: * -> *) a. Applicative f => NumBP (f a) -> f (NumBP a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NumBP a -> m (NumBP b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NumBP a -> m (NumBP b)
$csequence :: forall (m :: * -> *) a. Monad m => NumBP (m a) -> m (NumBP a)
sequence :: forall (m :: * -> *) a. Monad m => NumBP (m a) -> m (NumBP a)
Traversable
    , Integer -> NumBP a
NumBP a -> NumBP a
NumBP a -> NumBP a -> NumBP a
(NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (Integer -> NumBP a)
-> Num (NumBP a)
forall a. Num a => Integer -> NumBP a
forall a. Num a => NumBP a -> NumBP a
forall a. Num a => NumBP a -> NumBP a -> NumBP a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => NumBP a -> NumBP a -> NumBP a
+ :: NumBP a -> NumBP a -> NumBP a
$c- :: forall a. Num a => NumBP a -> NumBP a -> NumBP a
- :: NumBP a -> NumBP a -> NumBP a
$c* :: forall a. Num a => NumBP a -> NumBP a -> NumBP a
* :: NumBP a -> NumBP a -> NumBP a
$cnegate :: forall a. Num a => NumBP a -> NumBP a
negate :: NumBP a -> NumBP a
$cabs :: forall a. Num a => NumBP a -> NumBP a
abs :: NumBP a -> NumBP a
$csignum :: forall a. Num a => NumBP a -> NumBP a
signum :: NumBP a -> NumBP a
$cfromInteger :: forall a. Num a => Integer -> NumBP a
fromInteger :: Integer -> NumBP a
Num
    , Num (NumBP a)
Num (NumBP a) =>
(NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (Rational -> NumBP a)
-> Fractional (NumBP a)
Rational -> NumBP a
NumBP a -> NumBP a
NumBP a -> NumBP a -> NumBP a
forall a. Fractional a => Num (NumBP a)
forall a. Fractional a => Rational -> NumBP a
forall a. Fractional a => NumBP a -> NumBP a
forall a. Fractional a => NumBP a -> NumBP a -> NumBP a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a. Fractional a => NumBP a -> NumBP a -> NumBP a
/ :: NumBP a -> NumBP a -> NumBP a
$crecip :: forall a. Fractional a => NumBP a -> NumBP a
recip :: NumBP a -> NumBP a
$cfromRational :: forall a. Fractional a => Rational -> NumBP a
fromRational :: Rational -> NumBP a
Fractional
    , Fractional (NumBP a)
NumBP a
Fractional (NumBP a) =>
NumBP a
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> (NumBP a -> NumBP a)
-> Floating (NumBP a)
NumBP a -> NumBP a
NumBP a -> NumBP a -> NumBP a
forall a. Floating a => Fractional (NumBP a)
forall a. Floating a => NumBP a
forall a. Floating a => NumBP a -> NumBP a
forall a. Floating a => NumBP a -> NumBP a -> NumBP a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: forall a. Floating a => NumBP a
pi :: NumBP a
$cexp :: forall a. Floating a => NumBP a -> NumBP a
exp :: NumBP a -> NumBP a
$clog :: forall a. Floating a => NumBP a -> NumBP a
log :: NumBP a -> NumBP a
$csqrt :: forall a. Floating a => NumBP a -> NumBP a
sqrt :: NumBP a -> NumBP a
$c** :: forall a. Floating a => NumBP a -> NumBP a -> NumBP a
** :: NumBP a -> NumBP a -> NumBP a
$clogBase :: forall a. Floating a => NumBP a -> NumBP a -> NumBP a
logBase :: NumBP a -> NumBP a -> NumBP a
$csin :: forall a. Floating a => NumBP a -> NumBP a
sin :: NumBP a -> NumBP a
$ccos :: forall a. Floating a => NumBP a -> NumBP a
cos :: NumBP a -> NumBP a
$ctan :: forall a. Floating a => NumBP a -> NumBP a
tan :: NumBP a -> NumBP a
$casin :: forall a. Floating a => NumBP a -> NumBP a
asin :: NumBP a -> NumBP a
$cacos :: forall a. Floating a => NumBP a -> NumBP a
acos :: NumBP a -> NumBP a
$catan :: forall a. Floating a => NumBP a -> NumBP a
atan :: NumBP a -> NumBP a
$csinh :: forall a. Floating a => NumBP a -> NumBP a
sinh :: NumBP a -> NumBP a
$ccosh :: forall a. Floating a => NumBP a -> NumBP a
cosh :: NumBP a -> NumBP a
$ctanh :: forall a. Floating a => NumBP a -> NumBP a
tanh :: NumBP a -> NumBP a
$casinh :: forall a. Floating a => NumBP a -> NumBP a
asinh :: NumBP a -> NumBP a
$cacosh :: forall a. Floating a => NumBP a -> NumBP a
acosh :: NumBP a -> NumBP a
$catanh :: forall a. Floating a => NumBP a -> NumBP a
atanh :: NumBP a -> NumBP a
$clog1p :: forall a. Floating a => NumBP a -> NumBP a
log1p :: NumBP a -> NumBP a
$cexpm1 :: forall a. Floating a => NumBP a -> NumBP a
expm1 :: NumBP a -> NumBP a
$clog1pexp :: forall a. Floating a => NumBP a -> NumBP a
log1pexp :: NumBP a -> NumBP a
$clog1mexp :: forall a. Floating a => NumBP a -> NumBP a
log1mexp :: NumBP a -> NumBP a
Floating
    )

instance NFData a => NFData (NumBP a)

instance Applicative NumBP where
  pure :: forall a. a -> NumBP a
pure = a -> NumBP a
forall a. a -> NumBP a
NumBP
  {-# INLINE pure #-}
  NumBP (a -> b)
f <*> :: forall a b. NumBP (a -> b) -> NumBP a -> NumBP b
<*> NumBP a
x = b -> NumBP b
forall a. a -> NumBP a
NumBP (b -> NumBP b) -> b -> NumBP b
forall a b. (a -> b) -> a -> b
$ NumBP (a -> b) -> a -> b
forall a. NumBP a -> a
runNumBP NumBP (a -> b)
f (NumBP a -> a
forall a. NumBP a -> a
runNumBP NumBP a
x)
  {-# INLINE (<*>) #-}

instance Monad NumBP where
  NumBP a
x >>= :: forall a b. NumBP a -> (a -> NumBP b) -> NumBP b
>>= a -> NumBP b
f = a -> NumBP b
f (NumBP a -> a
forall a. NumBP a -> a
runNumBP NumBP a
x)
  {-# INLINE (>>=) #-}

instance Num a => Backprop (NumBP a) where
  zero :: NumBP a -> NumBP a
zero = (a -> a) -> NumBP a -> NumBP a
forall a b. Coercible a b => a -> b
coerce (a -> a
forall a. Num a => a -> a
zeroNum :: a -> a)
  {-# INLINE zero #-}
  add :: NumBP a -> NumBP a -> NumBP a
add = (a -> a -> a) -> NumBP a -> NumBP a -> NumBP a
forall a b. Coercible a b => a -> b
coerce (a -> a -> a
forall a. Num a => a -> a -> a
addNum :: a -> a -> a)
  {-# INLINE add #-}
  one :: NumBP a -> NumBP a
one = (a -> a) -> NumBP a -> NumBP a
forall a b. Coercible a b => a -> b
coerce (a -> a
forall a. Num a => a -> a
oneNum :: a -> a)
  {-# INLINE one #-}

-- | Newtype wrapper around a @v a@ for @'VG.Vector' v a@, that gives
-- a more efficient 'Backprop' instance for /long/ vectors when @a@ is an
-- instance of 'Num'.  The normal 'Backprop' instance for vectors will map
-- 'zero' or 'one' over all items; this instance will completely ignore the
-- contents of the original vector and instead produce a new vector of the
-- same length, with all @0@ or @1@ using the 'Num' instance of @a@
-- (essentially using 'zeroVecNum' and 'oneVecNum' instead of 'zeroVec' and
-- 'oneVec').
--
-- 'add' is essentially the same as normal, but using '+' instead of the
-- type's 'add'.
--
-- @since 0.2.4.0
newtype NumVec v a = NumVec {forall (v :: * -> *) a. NumVec v a -> v a
runNumVec :: v a}
  deriving
    ( Int -> NumVec v a -> ShowS
[NumVec v a] -> ShowS
NumVec v a -> String
(Int -> NumVec v a -> ShowS)
-> (NumVec v a -> String)
-> ([NumVec v a] -> ShowS)
-> Show (NumVec v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (v :: * -> *) a. Show (v a) => Int -> NumVec v a -> ShowS
forall (v :: * -> *) a. Show (v a) => [NumVec v a] -> ShowS
forall (v :: * -> *) a. Show (v a) => NumVec v a -> String
$cshowsPrec :: forall (v :: * -> *) a. Show (v a) => Int -> NumVec v a -> ShowS
showsPrec :: Int -> NumVec v a -> ShowS
$cshow :: forall (v :: * -> *) a. Show (v a) => NumVec v a -> String
show :: NumVec v a -> String
$cshowList :: forall (v :: * -> *) a. Show (v a) => [NumVec v a] -> ShowS
showList :: [NumVec v a] -> ShowS
Show
    , ReadPrec [NumVec v a]
ReadPrec (NumVec v a)
Int -> ReadS (NumVec v a)
ReadS [NumVec v a]
(Int -> ReadS (NumVec v a))
-> ReadS [NumVec v a]
-> ReadPrec (NumVec v a)
-> ReadPrec [NumVec v a]
-> Read (NumVec v a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall (v :: * -> *) a. Read (v a) => ReadPrec [NumVec v a]
forall (v :: * -> *) a. Read (v a) => ReadPrec (NumVec v a)
forall (v :: * -> *) a. Read (v a) => Int -> ReadS (NumVec v a)
forall (v :: * -> *) a. Read (v a) => ReadS [NumVec v a]
$creadsPrec :: forall (v :: * -> *) a. Read (v a) => Int -> ReadS (NumVec v a)
readsPrec :: Int -> ReadS (NumVec v a)
$creadList :: forall (v :: * -> *) a. Read (v a) => ReadS [NumVec v a]
readList :: ReadS [NumVec v a]
$creadPrec :: forall (v :: * -> *) a. Read (v a) => ReadPrec (NumVec v a)
readPrec :: ReadPrec (NumVec v a)
$creadListPrec :: forall (v :: * -> *) a. Read (v a) => ReadPrec [NumVec v a]
readListPrec :: ReadPrec [NumVec v a]
Read
    , NumVec v a -> NumVec v a -> Bool
(NumVec v a -> NumVec v a -> Bool)
-> (NumVec v a -> NumVec v a -> Bool) -> Eq (NumVec v a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (v :: * -> *) a.
Eq (v a) =>
NumVec v a -> NumVec v a -> Bool
$c== :: forall (v :: * -> *) a.
Eq (v a) =>
NumVec v a -> NumVec v a -> Bool
== :: NumVec v a -> NumVec v a -> Bool
$c/= :: forall (v :: * -> *) a.
Eq (v a) =>
NumVec v a -> NumVec v a -> Bool
/= :: NumVec v a -> NumVec v a -> Bool
Eq
    , Eq (NumVec v a)
Eq (NumVec v a) =>
(NumVec v a -> NumVec v a -> Ordering)
-> (NumVec v a -> NumVec v a -> Bool)
-> (NumVec v a -> NumVec v a -> Bool)
-> (NumVec v a -> NumVec v a -> Bool)
-> (NumVec v a -> NumVec v a -> Bool)
-> (NumVec v a -> NumVec v a -> NumVec v a)
-> (NumVec v a -> NumVec v a -> NumVec v a)
-> Ord (NumVec v a)
NumVec v a -> NumVec v a -> Bool
NumVec v a -> NumVec v a -> Ordering
NumVec v a -> NumVec v a -> NumVec v a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (v :: * -> *) a. Ord (v a) => Eq (NumVec v a)
forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Bool
forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Ordering
forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> NumVec v a
$ccompare :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Ordering
compare :: NumVec v a -> NumVec v a -> Ordering
$c< :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Bool
< :: NumVec v a -> NumVec v a -> Bool
$c<= :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Bool
<= :: NumVec v a -> NumVec v a -> Bool
$c> :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Bool
> :: NumVec v a -> NumVec v a -> Bool
$c>= :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> Bool
>= :: NumVec v a -> NumVec v a -> Bool
$cmax :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> NumVec v a
max :: NumVec v a -> NumVec v a -> NumVec v a
$cmin :: forall (v :: * -> *) a.
Ord (v a) =>
NumVec v a -> NumVec v a -> NumVec v a
min :: NumVec v a -> NumVec v a -> NumVec v a
Ord
    , Typeable
    , Typeable (NumVec v a)
Typeable (NumVec v a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NumVec v a -> c (NumVec v a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NumVec v a))
-> (NumVec v a -> Constr)
-> (NumVec v a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NumVec v a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NumVec v a)))
-> ((forall b. Data b => b -> b) -> NumVec v a -> NumVec v a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumVec v a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumVec v a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NumVec v a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NumVec v a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a))
-> Data (NumVec v a)
NumVec v a -> Constr
NumVec v a -> DataType
(forall b. Data b => b -> b) -> NumVec v a -> NumVec v a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NumVec v a -> u
forall u. (forall d. Data d => d -> u) -> NumVec v a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumVec v a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumVec v a -> c (NumVec v a)
forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
Typeable (NumVec v a)
forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
NumVec v a -> Constr
forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
NumVec v a -> DataType
forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
(forall b. Data b => b -> b) -> NumVec v a -> NumVec v a
forall (v :: * -> *) a u.
(Typeable v, Typeable a, Data (v a)) =>
Int -> (forall d. Data d => d -> u) -> NumVec v a -> u
forall (v :: * -> *) a u.
(Typeable v, Typeable a, Data (v a)) =>
(forall d. Data d => d -> u) -> NumVec v a -> [u]
forall (v :: * -> *) a r r'.
(Typeable v, Typeable a, Data (v a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
forall (v :: * -> *) a r r'.
(Typeable v, Typeable a, Data (v a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
forall (v :: * -> *) a (m :: * -> *).
(Typeable v, Typeable a, Data (v a), Monad m) =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
forall (v :: * -> *) a (m :: * -> *).
(Typeable v, Typeable a, Data (v a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
forall (v :: * -> *) a (c :: * -> *).
(Typeable v, Typeable a, Data (v a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumVec v a)
forall (v :: * -> *) a (c :: * -> *).
(Typeable v, Typeable a, Data (v a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumVec v a -> c (NumVec v a)
forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable v, Typeable a, Data (v a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NumVec v a))
forall (v :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable v, Typeable a, Data (v a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NumVec v a))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NumVec v a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NumVec v a))
$cgfoldl :: forall (v :: * -> *) a (c :: * -> *).
(Typeable v, Typeable a, Data (v a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumVec v a -> c (NumVec v a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumVec v a -> c (NumVec v a)
$cgunfold :: forall (v :: * -> *) a (c :: * -> *).
(Typeable v, Typeable a, Data (v a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumVec v a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NumVec v a)
$ctoConstr :: forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
NumVec v a -> Constr
toConstr :: NumVec v a -> Constr
$cdataTypeOf :: forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
NumVec v a -> DataType
dataTypeOf :: NumVec v a -> DataType
$cdataCast1 :: forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable v, Typeable a, Data (v a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NumVec v a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NumVec v a))
$cdataCast2 :: forall (v :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable v, Typeable a, Data (v a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NumVec v a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NumVec v a))
$cgmapT :: forall (v :: * -> *) a.
(Typeable v, Typeable a, Data (v a)) =>
(forall b. Data b => b -> b) -> NumVec v a -> NumVec v a
gmapT :: (forall b. Data b => b -> b) -> NumVec v a -> NumVec v a
$cgmapQl :: forall (v :: * -> *) a r r'.
(Typeable v, Typeable a, Data (v a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
$cgmapQr :: forall (v :: * -> *) a r r'.
(Typeable v, Typeable a, Data (v a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumVec v a -> r
$cgmapQ :: forall (v :: * -> *) a u.
(Typeable v, Typeable a, Data (v a)) =>
(forall d. Data d => d -> u) -> NumVec v a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NumVec v a -> [u]
$cgmapQi :: forall (v :: * -> *) a u.
(Typeable v, Typeable a, Data (v a)) =>
Int -> (forall d. Data d => d -> u) -> NumVec v a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NumVec v a -> u
$cgmapM :: forall (v :: * -> *) a (m :: * -> *).
(Typeable v, Typeable a, Data (v a), Monad m) =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
$cgmapMp :: forall (v :: * -> *) a (m :: * -> *).
(Typeable v, Typeable a, Data (v a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
$cgmapMo :: forall (v :: * -> *) a (m :: * -> *).
(Typeable v, Typeable a, Data (v a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumVec v a -> m (NumVec v a)
Data
    , (forall x. NumVec v a -> Rep (NumVec v a) x)
-> (forall x. Rep (NumVec v a) x -> NumVec v a)
-> Generic (NumVec v a)
forall x. Rep (NumVec v a) x -> NumVec v a
forall x. NumVec v a -> Rep (NumVec v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (v :: * -> *) a x. Rep (NumVec v a) x -> NumVec v a
forall (v :: * -> *) a x. NumVec v a -> Rep (NumVec v a) x
$cfrom :: forall (v :: * -> *) a x. NumVec v a -> Rep (NumVec v a) x
from :: forall x. NumVec v a -> Rep (NumVec v a) x
$cto :: forall (v :: * -> *) a x. Rep (NumVec v a) x -> NumVec v a
to :: forall x. Rep (NumVec v a) x -> NumVec v a
Generic
    , (forall a b. (a -> b) -> NumVec v a -> NumVec v b)
-> (forall a b. a -> NumVec v b -> NumVec v a)
-> Functor (NumVec v)
forall a b. a -> NumVec v b -> NumVec v a
forall a b. (a -> b) -> NumVec v a -> NumVec v b
forall (v :: * -> *) a b.
Functor v =>
a -> NumVec v b -> NumVec v a
forall (v :: * -> *) a b.
Functor v =>
(a -> b) -> NumVec v a -> NumVec v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (v :: * -> *) a b.
Functor v =>
(a -> b) -> NumVec v a -> NumVec v b
fmap :: forall a b. (a -> b) -> NumVec v a -> NumVec v b
$c<$ :: forall (v :: * -> *) a b.
Functor v =>
a -> NumVec v b -> NumVec v a
<$ :: forall a b. a -> NumVec v b -> NumVec v a
Functor
    , Functor (NumVec v)
Functor (NumVec v) =>
(forall a. a -> NumVec v a)
-> (forall a b. NumVec v (a -> b) -> NumVec v a -> NumVec v b)
-> (forall a b c.
    (a -> b -> c) -> NumVec v a -> NumVec v b -> NumVec v c)
-> (forall a b. NumVec v a -> NumVec v b -> NumVec v b)
-> (forall a b. NumVec v a -> NumVec v b -> NumVec v a)
-> Applicative (NumVec v)
forall a. a -> NumVec v a
forall a b. NumVec v a -> NumVec v b -> NumVec v a
forall a b. NumVec v a -> NumVec v b -> NumVec v b
forall a b. NumVec v (a -> b) -> NumVec v a -> NumVec v b
forall a b c.
(a -> b -> c) -> NumVec v a -> NumVec v b -> NumVec v c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (v :: * -> *). Applicative v => Functor (NumVec v)
forall (v :: * -> *) a. Applicative v => a -> NumVec v a
forall (v :: * -> *) a b.
Applicative v =>
NumVec v a -> NumVec v b -> NumVec v a
forall (v :: * -> *) a b.
Applicative v =>
NumVec v a -> NumVec v b -> NumVec v b
forall (v :: * -> *) a b.
Applicative v =>
NumVec v (a -> b) -> NumVec v a -> NumVec v b
forall (v :: * -> *) a b c.
Applicative v =>
(a -> b -> c) -> NumVec v a -> NumVec v b -> NumVec v c
$cpure :: forall (v :: * -> *) a. Applicative v => a -> NumVec v a
pure :: forall a. a -> NumVec v a
$c<*> :: forall (v :: * -> *) a b.
Applicative v =>
NumVec v (a -> b) -> NumVec v a -> NumVec v b
<*> :: forall a b. NumVec v (a -> b) -> NumVec v a -> NumVec v b
$cliftA2 :: forall (v :: * -> *) a b c.
Applicative v =>
(a -> b -> c) -> NumVec v a -> NumVec v b -> NumVec v c
liftA2 :: forall a b c.
(a -> b -> c) -> NumVec v a -> NumVec v b -> NumVec v c
$c*> :: forall (v :: * -> *) a b.
Applicative v =>
NumVec v a -> NumVec v b -> NumVec v b
*> :: forall a b. NumVec v a -> NumVec v b -> NumVec v b
$c<* :: forall (v :: * -> *) a b.
Applicative v =>
NumVec v a -> NumVec v b -> NumVec v a
<* :: forall a b. NumVec v a -> NumVec v b -> NumVec v a
Applicative
    , Applicative (NumVec v)
Applicative (NumVec v) =>
(forall a b. NumVec v a -> (a -> NumVec v b) -> NumVec v b)
-> (forall a b. NumVec v a -> NumVec v b -> NumVec v b)
-> (forall a. a -> NumVec v a)
-> Monad (NumVec v)
forall a. a -> NumVec v a
forall a b. NumVec v a -> NumVec v b -> NumVec v b
forall a b. NumVec v a -> (a -> NumVec v b) -> NumVec v b
forall (v :: * -> *). Monad v => Applicative (NumVec v)
forall (v :: * -> *) a. Monad v => a -> NumVec v a
forall (v :: * -> *) a b.
Monad v =>
NumVec v a -> NumVec v b -> NumVec v b
forall (v :: * -> *) a b.
Monad v =>
NumVec v a -> (a -> NumVec v b) -> NumVec v b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (v :: * -> *) a b.
Monad v =>
NumVec v a -> (a -> NumVec v b) -> NumVec v b
>>= :: forall a b. NumVec v a -> (a -> NumVec v b) -> NumVec v b
$c>> :: forall (v :: * -> *) a b.
Monad v =>
NumVec v a -> NumVec v b -> NumVec v b
>> :: forall a b. NumVec v a -> NumVec v b -> NumVec v b
$creturn :: forall (v :: * -> *) a. Monad v => a -> NumVec v a
return :: forall a. a -> NumVec v a
Monad
    , Applicative (NumVec v)
Applicative (NumVec v) =>
(forall a. NumVec v a)
-> (forall a. NumVec v a -> NumVec v a -> NumVec v a)
-> (forall a. NumVec v a -> NumVec v [a])
-> (forall a. NumVec v a -> NumVec v [a])
-> Alternative (NumVec v)
forall a. NumVec v a
forall a. NumVec v a -> NumVec v [a]
forall a. NumVec v a -> NumVec v a -> NumVec v a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (v :: * -> *). Alternative v => Applicative (NumVec v)
forall (v :: * -> *) a. Alternative v => NumVec v a
forall (v :: * -> *) a. Alternative v => NumVec v a -> NumVec v [a]
forall (v :: * -> *) a.
Alternative v =>
NumVec v a -> NumVec v a -> NumVec v a
$cempty :: forall (v :: * -> *) a. Alternative v => NumVec v a
empty :: forall a. NumVec v a
$c<|> :: forall (v :: * -> *) a.
Alternative v =>
NumVec v a -> NumVec v a -> NumVec v a
<|> :: forall a. NumVec v a -> NumVec v a -> NumVec v a
$csome :: forall (v :: * -> *) a. Alternative v => NumVec v a -> NumVec v [a]
some :: forall a. NumVec v a -> NumVec v [a]
$cmany :: forall (v :: * -> *) a. Alternative v => NumVec v a -> NumVec v [a]
many :: forall a. NumVec v a -> NumVec v [a]
Alternative
    , Monad (NumVec v)
Alternative (NumVec v)
(Alternative (NumVec v), Monad (NumVec v)) =>
(forall a. NumVec v a)
-> (forall a. NumVec v a -> NumVec v a -> NumVec v a)
-> MonadPlus (NumVec v)
forall a. NumVec v a
forall a. NumVec v a -> NumVec v a -> NumVec v a
forall (v :: * -> *). MonadPlus v => Monad (NumVec v)
forall (v :: * -> *). MonadPlus v => Alternative (NumVec v)
forall (v :: * -> *) a. MonadPlus v => NumVec v a
forall (v :: * -> *) a.
MonadPlus v =>
NumVec v a -> NumVec v a -> NumVec v a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
$cmzero :: forall (v :: * -> *) a. MonadPlus v => NumVec v a
mzero :: forall a. NumVec v a
$cmplus :: forall (v :: * -> *) a.
MonadPlus v =>
NumVec v a -> NumVec v a -> NumVec v a
mplus :: forall a. NumVec v a -> NumVec v a -> NumVec v a
MonadPlus
    , (forall m. Monoid m => NumVec v m -> m)
-> (forall m a. Monoid m => (a -> m) -> NumVec v a -> m)
-> (forall m a. Monoid m => (a -> m) -> NumVec v a -> m)
-> (forall a b. (a -> b -> b) -> b -> NumVec v a -> b)
-> (forall a b. (a -> b -> b) -> b -> NumVec v a -> b)
-> (forall b a. (b -> a -> b) -> b -> NumVec v a -> b)
-> (forall b a. (b -> a -> b) -> b -> NumVec v a -> b)
-> (forall a. (a -> a -> a) -> NumVec v a -> a)
-> (forall a. (a -> a -> a) -> NumVec v a -> a)
-> (forall a. NumVec v a -> [a])
-> (forall a. NumVec v a -> Bool)
-> (forall a. NumVec v a -> Int)
-> (forall a. Eq a => a -> NumVec v a -> Bool)
-> (forall a. Ord a => NumVec v a -> a)
-> (forall a. Ord a => NumVec v a -> a)
-> (forall a. Num a => NumVec v a -> a)
-> (forall a. Num a => NumVec v a -> a)
-> Foldable (NumVec v)
forall a. Eq a => a -> NumVec v a -> Bool
forall a. Num a => NumVec v a -> a
forall a. Ord a => NumVec v a -> a
forall m. Monoid m => NumVec v m -> m
forall a. NumVec v a -> Bool
forall a. NumVec v a -> Int
forall a. NumVec v a -> [a]
forall a. (a -> a -> a) -> NumVec v a -> a
forall m a. Monoid m => (a -> m) -> NumVec v a -> m
forall b a. (b -> a -> b) -> b -> NumVec v a -> b
forall a b. (a -> b -> b) -> b -> NumVec v a -> b
forall (v :: * -> *) a.
(Foldable v, Eq a) =>
a -> NumVec v a -> Bool
forall (v :: * -> *) a. (Foldable v, Num a) => NumVec v a -> a
forall (v :: * -> *) a. (Foldable v, Ord a) => NumVec v a -> a
forall (v :: * -> *) m. (Foldable v, Monoid m) => NumVec v m -> m
forall (v :: * -> *) a. Foldable v => NumVec v a -> Bool
forall (v :: * -> *) a. Foldable v => NumVec v a -> Int
forall (v :: * -> *) a. Foldable v => NumVec v a -> [a]
forall (v :: * -> *) a.
Foldable v =>
(a -> a -> a) -> NumVec v a -> a
forall (v :: * -> *) m a.
(Foldable v, Monoid m) =>
(a -> m) -> NumVec v a -> m
forall (v :: * -> *) b a.
Foldable v =>
(b -> a -> b) -> b -> NumVec v a -> b
forall (v :: * -> *) a b.
Foldable v =>
(a -> b -> b) -> b -> NumVec v a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (v :: * -> *) m. (Foldable v, Monoid m) => NumVec v m -> m
fold :: forall m. Monoid m => NumVec v m -> m
$cfoldMap :: forall (v :: * -> *) m a.
(Foldable v, Monoid m) =>
(a -> m) -> NumVec v a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NumVec v a -> m
$cfoldMap' :: forall (v :: * -> *) m a.
(Foldable v, Monoid m) =>
(a -> m) -> NumVec v a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NumVec v a -> m
$cfoldr :: forall (v :: * -> *) a b.
Foldable v =>
(a -> b -> b) -> b -> NumVec v a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NumVec v a -> b
$cfoldr' :: forall (v :: * -> *) a b.
Foldable v =>
(a -> b -> b) -> b -> NumVec v a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NumVec v a -> b
$cfoldl :: forall (v :: * -> *) b a.
Foldable v =>
(b -> a -> b) -> b -> NumVec v a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NumVec v a -> b
$cfoldl' :: forall (v :: * -> *) b a.
Foldable v =>
(b -> a -> b) -> b -> NumVec v a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NumVec v a -> b
$cfoldr1 :: forall (v :: * -> *) a.
Foldable v =>
(a -> a -> a) -> NumVec v a -> a
foldr1 :: forall a. (a -> a -> a) -> NumVec v a -> a
$cfoldl1 :: forall (v :: * -> *) a.
Foldable v =>
(a -> a -> a) -> NumVec v a -> a
foldl1 :: forall a. (a -> a -> a) -> NumVec v a -> a
$ctoList :: forall (v :: * -> *) a. Foldable v => NumVec v a -> [a]
toList :: forall a. NumVec v a -> [a]
$cnull :: forall (v :: * -> *) a. Foldable v => NumVec v a -> Bool
null :: forall a. NumVec v a -> Bool
$clength :: forall (v :: * -> *) a. Foldable v => NumVec v a -> Int
length :: forall a. NumVec v a -> Int
$celem :: forall (v :: * -> *) a.
(Foldable v, Eq a) =>
a -> NumVec v a -> Bool
elem :: forall a. Eq a => a -> NumVec v a -> Bool
$cmaximum :: forall (v :: * -> *) a. (Foldable v, Ord a) => NumVec v a -> a
maximum :: forall a. Ord a => NumVec v a -> a
$cminimum :: forall (v :: * -> *) a. (Foldable v, Ord a) => NumVec v a -> a
minimum :: forall a. Ord a => NumVec v a -> a
$csum :: forall (v :: * -> *) a. (Foldable v, Num a) => NumVec v a -> a
sum :: forall a. Num a => NumVec v a -> a
$cproduct :: forall (v :: * -> *) a. (Foldable v, Num a) => NumVec v a -> a
product :: forall a. Num a => NumVec v a -> a
Foldable
    , Functor (NumVec v)
Foldable (NumVec v)
(Functor (NumVec v), Foldable (NumVec v)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NumVec v a -> f (NumVec v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NumVec v (f a) -> f (NumVec v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NumVec v a -> m (NumVec v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NumVec v (m a) -> m (NumVec v a))
-> Traversable (NumVec v)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (v :: * -> *). Traversable v => Functor (NumVec v)
forall (v :: * -> *). Traversable v => Foldable (NumVec v)
forall (v :: * -> *) (m :: * -> *) a.
(Traversable v, Monad m) =>
NumVec v (m a) -> m (NumVec v a)
forall (v :: * -> *) (f :: * -> *) a.
(Traversable v, Applicative f) =>
NumVec v (f a) -> f (NumVec v a)
forall (v :: * -> *) (m :: * -> *) a b.
(Traversable v, Monad m) =>
(a -> m b) -> NumVec v a -> m (NumVec v b)
forall (v :: * -> *) (f :: * -> *) a b.
(Traversable v, Applicative f) =>
(a -> f b) -> NumVec v a -> f (NumVec v b)
forall (m :: * -> *) a. Monad m => NumVec v (m a) -> m (NumVec v a)
forall (f :: * -> *) a.
Applicative f =>
NumVec v (f a) -> f (NumVec v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NumVec v a -> m (NumVec v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NumVec v a -> f (NumVec v b)
$ctraverse :: forall (v :: * -> *) (f :: * -> *) a b.
(Traversable v, Applicative f) =>
(a -> f b) -> NumVec v a -> f (NumVec v b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NumVec v a -> f (NumVec v b)
$csequenceA :: forall (v :: * -> *) (f :: * -> *) a.
(Traversable v, Applicative f) =>
NumVec v (f a) -> f (NumVec v a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NumVec v (f a) -> f (NumVec v a)
$cmapM :: forall (v :: * -> *) (m :: * -> *) a b.
(Traversable v, Monad m) =>
(a -> m b) -> NumVec v a -> m (NumVec v b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NumVec v a -> m (NumVec v b)
$csequence :: forall (v :: * -> *) (m :: * -> *) a.
(Traversable v, Monad m) =>
NumVec v (m a) -> m (NumVec v a)
sequence :: forall (m :: * -> *) a. Monad m => NumVec v (m a) -> m (NumVec v a)
Traversable
    )

instance NFData (v a) => NFData (NumVec v a)

instance (VG.Vector v a, Num a) => Backprop (NumVec v a) where
  zero :: NumVec v a -> NumVec v a
zero = (v a -> v a) -> NumVec v a -> NumVec v a
forall a b. Coercible a b => a -> b
coerce ((v a -> v a) -> NumVec v a -> NumVec v a)
-> (v a -> v a) -> NumVec v a -> NumVec v a
forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. (Vector v a, Num a) => v a -> v a
zeroVecNum @v @a
  add :: NumVec v a -> NumVec v a -> NumVec v a
add (NumVec v a
x) (NumVec v a
y) = v a -> NumVec v a
forall (v :: * -> *) a. v a -> NumVec v a
NumVec (v a -> NumVec v a) -> v a -> NumVec v a
forall a b. (a -> b) -> a -> b
$ case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
lX Int
lY of
    Ordering
LT ->
      let (v a
y1, v a
y2) = Int -> v a -> (v a, v a)
forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
VG.splitAt (Int
lY Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lX) v a
y
       in (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Num a => a -> a -> a
(+) v a
x v a
y1 v a -> v a -> v a
forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
VG.++ v a
y2
    Ordering
EQ -> (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Num a => a -> a -> a
(+) v a
x v a
y
    Ordering
GT ->
      let (v a
x1, v a
x2) = Int -> v a -> (v a, v a)
forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
VG.splitAt (Int
lX Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lY) v a
x
       in (a -> a -> a) -> v a -> v a -> v a
forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
VG.zipWith a -> a -> a
forall a. Num a => a -> a -> a
(+) v a
x1 v a
y v a -> v a -> v a
forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
VG.++ v a
x2
    where
      lX :: Int
lX = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length v a
x
      lY :: Int
lY = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
VG.length v a
y
  one :: NumVec v a -> NumVec v a
one = (v a -> v a) -> NumVec v a -> NumVec v a
forall a b. Coercible a b => a -> b
coerce ((v a -> v a) -> NumVec v a -> NumVec v a)
-> (v a -> v a) -> NumVec v a -> NumVec v a
forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. (Vector v a, Num a) => v a -> v a
oneVecNum @v @a

-- | A newtype wrapper over an @f a@ for @'Applicative' f@ that gives
-- a free 'Backprop' instance (as well as 'Num' etc. instances).
--
-- Useful for performing backpropagation over functions that require some
-- monadic context (like 'IO') to perform.
--
-- @since 0.2.1.0
newtype ABP f a = ABP {forall (f :: * -> *) a. ABP f a -> f a
runABP :: f a}
  deriving
    ( Int -> ABP f a -> ShowS
[ABP f a] -> ShowS
ABP f a -> String
(Int -> ABP f a -> ShowS)
-> (ABP f a -> String) -> ([ABP f a] -> ShowS) -> Show (ABP f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) a. Show (f a) => Int -> ABP f a -> ShowS
forall (f :: * -> *) a. Show (f a) => [ABP f a] -> ShowS
forall (f :: * -> *) a. Show (f a) => ABP f a -> String
$cshowsPrec :: forall (f :: * -> *) a. Show (f a) => Int -> ABP f a -> ShowS
showsPrec :: Int -> ABP f a -> ShowS
$cshow :: forall (f :: * -> *) a. Show (f a) => ABP f a -> String
show :: ABP f a -> String
$cshowList :: forall (f :: * -> *) a. Show (f a) => [ABP f a] -> ShowS
showList :: [ABP f a] -> ShowS
Show
    , ReadPrec [ABP f a]
ReadPrec (ABP f a)
Int -> ReadS (ABP f a)
ReadS [ABP f a]
(Int -> ReadS (ABP f a))
-> ReadS [ABP f a]
-> ReadPrec (ABP f a)
-> ReadPrec [ABP f a]
-> Read (ABP f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall (f :: * -> *) a. Read (f a) => ReadPrec [ABP f a]
forall (f :: * -> *) a. Read (f a) => ReadPrec (ABP f a)
forall (f :: * -> *) a. Read (f a) => Int -> ReadS (ABP f a)
forall (f :: * -> *) a. Read (f a) => ReadS [ABP f a]
$creadsPrec :: forall (f :: * -> *) a. Read (f a) => Int -> ReadS (ABP f a)
readsPrec :: Int -> ReadS (ABP f a)
$creadList :: forall (f :: * -> *) a. Read (f a) => ReadS [ABP f a]
readList :: ReadS [ABP f a]
$creadPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec (ABP f a)
readPrec :: ReadPrec (ABP f a)
$creadListPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec [ABP f a]
readListPrec :: ReadPrec [ABP f a]
Read
    , ABP f a -> ABP f a -> Bool
(ABP f a -> ABP f a -> Bool)
-> (ABP f a -> ABP f a -> Bool) -> Eq (ABP f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) a. Eq (f a) => ABP f a -> ABP f a -> Bool
$c== :: forall (f :: * -> *) a. Eq (f a) => ABP f a -> ABP f a -> Bool
== :: ABP f a -> ABP f a -> Bool
$c/= :: forall (f :: * -> *) a. Eq (f a) => ABP f a -> ABP f a -> Bool
/= :: ABP f a -> ABP f a -> Bool
Eq
    , Eq (ABP f a)
Eq (ABP f a) =>
(ABP f a -> ABP f a -> Ordering)
-> (ABP f a -> ABP f a -> Bool)
-> (ABP f a -> ABP f a -> Bool)
-> (ABP f a -> ABP f a -> Bool)
-> (ABP f a -> ABP f a -> Bool)
-> (ABP f a -> ABP f a -> ABP f a)
-> (ABP f a -> ABP f a -> ABP f a)
-> Ord (ABP f a)
ABP f a -> ABP f a -> Bool
ABP f a -> ABP f a -> Ordering
ABP f a -> ABP f a -> ABP f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (f :: * -> *) a. Ord (f a) => Eq (ABP f a)
forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Bool
forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Ordering
forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> ABP f a
$ccompare :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Ordering
compare :: ABP f a -> ABP f a -> Ordering
$c< :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Bool
< :: ABP f a -> ABP f a -> Bool
$c<= :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Bool
<= :: ABP f a -> ABP f a -> Bool
$c> :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Bool
> :: ABP f a -> ABP f a -> Bool
$c>= :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> Bool
>= :: ABP f a -> ABP f a -> Bool
$cmax :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> ABP f a
max :: ABP f a -> ABP f a -> ABP f a
$cmin :: forall (f :: * -> *) a. Ord (f a) => ABP f a -> ABP f a -> ABP f a
min :: ABP f a -> ABP f a -> ABP f a
Ord
    , Typeable
    , Typeable (ABP f a)
Typeable (ABP f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ABP f a -> c (ABP f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ABP f a))
-> (ABP f a -> Constr)
-> (ABP f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ABP f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABP f a)))
-> ((forall b. Data b => b -> b) -> ABP f a -> ABP f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ABP f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ABP f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ABP f a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ABP f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a))
-> Data (ABP f a)
ABP f a -> Constr
ABP f a -> DataType
(forall b. Data b => b -> b) -> ABP f a -> ABP f a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ABP f a -> u
forall u. (forall d. Data d => d -> u) -> ABP f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ABP f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ABP f a -> c (ABP f a)
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
Typeable (ABP f a)
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
ABP f a -> Constr
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
ABP f a -> DataType
forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
(forall b. Data b => b -> b) -> ABP f a -> ABP f a
forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> ABP f a -> u
forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
(forall d. Data d => d -> u) -> ABP f a -> [u]
forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ABP f a)
forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ABP f a -> c (ABP f a)
forall (f :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ABP f a))
forall (f :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABP f a))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ABP f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABP f a))
$cgfoldl :: forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ABP f a -> c (ABP f a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ABP f a -> c (ABP f a)
$cgunfold :: forall (f :: * -> *) a (c :: * -> *).
(Typeable f, Typeable a, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ABP f a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ABP f a)
$ctoConstr :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
ABP f a -> Constr
toConstr :: ABP f a -> Constr
$cdataTypeOf :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
ABP f a -> DataType
dataTypeOf :: ABP f a -> DataType
$cdataCast1 :: forall (f :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ABP f a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ABP f a))
$cdataCast2 :: forall (f :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable a, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABP f a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABP f a))
$cgmapT :: forall (f :: * -> *) a.
(Typeable f, Typeable a, Data (f a)) =>
(forall b. Data b => b -> b) -> ABP f a -> ABP f a
gmapT :: (forall b. Data b => b -> b) -> ABP f a -> ABP f a
$cgmapQl :: forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
$cgmapQr :: forall (f :: * -> *) a r r'.
(Typeable f, Typeable a, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ABP f a -> r
$cgmapQ :: forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
(forall d. Data d => d -> u) -> ABP f a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ABP f a -> [u]
$cgmapQi :: forall (f :: * -> *) a u.
(Typeable f, Typeable a, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> ABP f a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ABP f a -> u
$cgmapM :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
$cgmapMp :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
$cgmapMo :: forall (f :: * -> *) a (m :: * -> *).
(Typeable f, Typeable a, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ABP f a -> m (ABP f a)
Data
    , (forall x. ABP f a -> Rep (ABP f a) x)
-> (forall x. Rep (ABP f a) x -> ABP f a) -> Generic (ABP f a)
forall x. Rep (ABP f a) x -> ABP f a
forall x. ABP f a -> Rep (ABP f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) a x. Rep (ABP f a) x -> ABP f a
forall (f :: * -> *) a x. ABP f a -> Rep (ABP f a) x
$cfrom :: forall (f :: * -> *) a x. ABP f a -> Rep (ABP f a) x
from :: forall x. ABP f a -> Rep (ABP f a) x
$cto :: forall (f :: * -> *) a x. Rep (ABP f a) x -> ABP f a
to :: forall x. Rep (ABP f a) x -> ABP f a
Generic
    , (forall a b. (a -> b) -> ABP f a -> ABP f b)
-> (forall a b. a -> ABP f b -> ABP f a) -> Functor (ABP f)
forall a b. a -> ABP f b -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => a -> ABP f b -> ABP f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ABP f a -> ABP f b
fmap :: forall a b. (a -> b) -> ABP f a -> ABP f b
$c<$ :: forall (f :: * -> *) a b. Functor f => a -> ABP f b -> ABP f a
<$ :: forall a b. a -> ABP f b -> ABP f a
Functor
    , Functor (ABP f)
Functor (ABP f) =>
(forall a. a -> ABP f a)
-> (forall a b. ABP f (a -> b) -> ABP f a -> ABP f b)
-> (forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c)
-> (forall a b. ABP f a -> ABP f b -> ABP f b)
-> (forall a b. ABP f a -> ABP f b -> ABP f a)
-> Applicative (ABP f)
forall a. a -> ABP f a
forall a b. ABP f a -> ABP f b -> ABP f a
forall a b. ABP f a -> ABP f b -> ABP f b
forall a b. ABP f (a -> b) -> ABP f a -> ABP f b
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (f :: * -> *). Applicative f => Functor (ABP f)
forall (f :: * -> *) a. Applicative f => a -> ABP f a
forall (f :: * -> *) a b.
Applicative f =>
ABP f a -> ABP f b -> ABP f a
forall (f :: * -> *) a b.
Applicative f =>
ABP f a -> ABP f b -> ABP f b
forall (f :: * -> *) a b.
Applicative f =>
ABP f (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
$cpure :: forall (f :: * -> *) a. Applicative f => a -> ABP f a
pure :: forall a. a -> ABP f a
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
ABP f (a -> b) -> ABP f a -> ABP f b
<*> :: forall a b. ABP f (a -> b) -> ABP f a -> ABP f b
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
liftA2 :: forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
ABP f a -> ABP f b -> ABP f b
*> :: forall a b. ABP f a -> ABP f b -> ABP f b
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
ABP f a -> ABP f b -> ABP f a
<* :: forall a b. ABP f a -> ABP f b -> ABP f a
Applicative
    , Applicative (ABP f)
Applicative (ABP f) =>
(forall a b. ABP f a -> (a -> ABP f b) -> ABP f b)
-> (forall a b. ABP f a -> ABP f b -> ABP f b)
-> (forall a. a -> ABP f a)
-> Monad (ABP f)
forall a. a -> ABP f a
forall a b. ABP f a -> ABP f b -> ABP f b
forall a b. ABP f a -> (a -> ABP f b) -> ABP f b
forall (f :: * -> *). Monad f => Applicative (ABP f)
forall (f :: * -> *) a. Monad f => a -> ABP f a
forall (f :: * -> *) a b. Monad f => ABP f a -> ABP f b -> ABP f b
forall (f :: * -> *) a b.
Monad f =>
ABP f a -> (a -> ABP f b) -> ABP f b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
ABP f a -> (a -> ABP f b) -> ABP f b
>>= :: forall a b. ABP f a -> (a -> ABP f b) -> ABP f b
$c>> :: forall (f :: * -> *) a b. Monad f => ABP f a -> ABP f b -> ABP f b
>> :: forall a b. ABP f a -> ABP f b -> ABP f b
$creturn :: forall (f :: * -> *) a. Monad f => a -> ABP f a
return :: forall a. a -> ABP f a
Monad
    , Applicative (ABP f)
Applicative (ABP f) =>
(forall a. ABP f a)
-> (forall a. ABP f a -> ABP f a -> ABP f a)
-> (forall a. ABP f a -> ABP f [a])
-> (forall a. ABP f a -> ABP f [a])
-> Alternative (ABP f)
forall a. ABP f a
forall a. ABP f a -> ABP f [a]
forall a. ABP f a -> ABP f a -> ABP f a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (f :: * -> *). Alternative f => Applicative (ABP f)
forall (f :: * -> *) a. Alternative f => ABP f a
forall (f :: * -> *) a. Alternative f => ABP f a -> ABP f [a]
forall (f :: * -> *) a.
Alternative f =>
ABP f a -> ABP f a -> ABP f a
$cempty :: forall (f :: * -> *) a. Alternative f => ABP f a
empty :: forall a. ABP f a
$c<|> :: forall (f :: * -> *) a.
Alternative f =>
ABP f a -> ABP f a -> ABP f a
<|> :: forall a. ABP f a -> ABP f a -> ABP f a
$csome :: forall (f :: * -> *) a. Alternative f => ABP f a -> ABP f [a]
some :: forall a. ABP f a -> ABP f [a]
$cmany :: forall (f :: * -> *) a. Alternative f => ABP f a -> ABP f [a]
many :: forall a. ABP f a -> ABP f [a]
Alternative
    , Monad (ABP f)
Alternative (ABP f)
(Alternative (ABP f), Monad (ABP f)) =>
(forall a. ABP f a)
-> (forall a. ABP f a -> ABP f a -> ABP f a) -> MonadPlus (ABP f)
forall a. ABP f a
forall a. ABP f a -> ABP f a -> ABP f a
forall (f :: * -> *). MonadPlus f => Monad (ABP f)
forall (f :: * -> *). MonadPlus f => Alternative (ABP f)
forall (f :: * -> *) a. MonadPlus f => ABP f a
forall (f :: * -> *) a.
MonadPlus f =>
ABP f a -> ABP f a -> ABP f a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
$cmzero :: forall (f :: * -> *) a. MonadPlus f => ABP f a
mzero :: forall a. ABP f a
$cmplus :: forall (f :: * -> *) a.
MonadPlus f =>
ABP f a -> ABP f a -> ABP f a
mplus :: forall a. ABP f a -> ABP f a -> ABP f a
MonadPlus
    , (forall m. Monoid m => ABP f m -> m)
-> (forall m a. Monoid m => (a -> m) -> ABP f a -> m)
-> (forall m a. Monoid m => (a -> m) -> ABP f a -> m)
-> (forall a b. (a -> b -> b) -> b -> ABP f a -> b)
-> (forall a b. (a -> b -> b) -> b -> ABP f a -> b)
-> (forall b a. (b -> a -> b) -> b -> ABP f a -> b)
-> (forall b a. (b -> a -> b) -> b -> ABP f a -> b)
-> (forall a. (a -> a -> a) -> ABP f a -> a)
-> (forall a. (a -> a -> a) -> ABP f a -> a)
-> (forall a. ABP f a -> [a])
-> (forall a. ABP f a -> Bool)
-> (forall a. ABP f a -> Int)
-> (forall a. Eq a => a -> ABP f a -> Bool)
-> (forall a. Ord a => ABP f a -> a)
-> (forall a. Ord a => ABP f a -> a)
-> (forall a. Num a => ABP f a -> a)
-> (forall a. Num a => ABP f a -> a)
-> Foldable (ABP f)
forall a. Eq a => a -> ABP f a -> Bool
forall a. Num a => ABP f a -> a
forall a. Ord a => ABP f a -> a
forall m. Monoid m => ABP f m -> m
forall a. ABP f a -> Bool
forall a. ABP f a -> Int
forall a. ABP f a -> [a]
forall a. (a -> a -> a) -> ABP f a -> a
forall m a. Monoid m => (a -> m) -> ABP f a -> m
forall b a. (b -> a -> b) -> b -> ABP f a -> b
forall a b. (a -> b -> b) -> b -> ABP f a -> b
forall (f :: * -> *) a. (Foldable f, Eq a) => a -> ABP f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => ABP f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => ABP f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => ABP f m -> m
forall (f :: * -> *) a. Foldable f => ABP f a -> Bool
forall (f :: * -> *) a. Foldable f => ABP f a -> Int
forall (f :: * -> *) a. Foldable f => ABP f a -> [a]
forall (f :: * -> *) a. Foldable f => (a -> a -> a) -> ABP f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ABP f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ABP f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ABP f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => ABP f m -> m
fold :: forall m. Monoid m => ABP f m -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ABP f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ABP f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ABP f a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ABP f a -> m
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ABP f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ABP f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ABP f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ABP f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ABP f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ABP f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ABP f a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ABP f a -> b
$cfoldr1 :: forall (f :: * -> *) a. Foldable f => (a -> a -> a) -> ABP f a -> a
foldr1 :: forall a. (a -> a -> a) -> ABP f a -> a
$cfoldl1 :: forall (f :: * -> *) a. Foldable f => (a -> a -> a) -> ABP f a -> a
foldl1 :: forall a. (a -> a -> a) -> ABP f a -> a
$ctoList :: forall (f :: * -> *) a. Foldable f => ABP f a -> [a]
toList :: forall a. ABP f a -> [a]
$cnull :: forall (f :: * -> *) a. Foldable f => ABP f a -> Bool
null :: forall a. ABP f a -> Bool
$clength :: forall (f :: * -> *) a. Foldable f => ABP f a -> Int
length :: forall a. ABP f a -> Int
$celem :: forall (f :: * -> *) a. (Foldable f, Eq a) => a -> ABP f a -> Bool
elem :: forall a. Eq a => a -> ABP f a -> Bool
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => ABP f a -> a
maximum :: forall a. Ord a => ABP f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => ABP f a -> a
minimum :: forall a. Ord a => ABP f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => ABP f a -> a
sum :: forall a. Num a => ABP f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => ABP f a -> a
product :: forall a. Num a => ABP f a -> a
Foldable
    , Functor (ABP f)
Foldable (ABP f)
(Functor (ABP f), Foldable (ABP f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ABP f a -> f (ABP f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ABP f (f a) -> f (ABP f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ABP f a -> m (ABP f b))
-> (forall (m :: * -> *) a. Monad m => ABP f (m a) -> m (ABP f a))
-> Traversable (ABP f)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *). Traversable f => Functor (ABP f)
forall (f :: * -> *). Traversable f => Foldable (ABP f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
ABP f (m a) -> m (ABP f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
ABP f (f a) -> f (ABP f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> ABP f a -> m (ABP f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> ABP f a -> f (ABP f b)
forall (m :: * -> *) a. Monad m => ABP f (m a) -> m (ABP f a)
forall (f :: * -> *) a. Applicative f => ABP f (f a) -> f (ABP f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ABP f a -> m (ABP f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ABP f a -> f (ABP f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> ABP f a -> f (ABP f b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ABP f a -> f (ABP f b)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
ABP f (f a) -> f (ABP f a)
sequenceA :: forall (f :: * -> *) a. Applicative f => ABP f (f a) -> f (ABP f a)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> ABP f a -> m (ABP f b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ABP f a -> m (ABP f b)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
ABP f (m a) -> m (ABP f a)
sequence :: forall (m :: * -> *) a. Monad m => ABP f (m a) -> m (ABP f a)
Traversable
    )

instance NFData (f a) => NFData (ABP f a)

instance (Applicative f, Backprop a) => Backprop (ABP f a) where
  zero :: ABP f a -> ABP f a
zero = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Backprop a => a -> a
zero
  {-# INLINE zero #-}
  add :: ABP f a -> ABP f a -> ABP f a
add = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Backprop a => a -> a -> a
add
  {-# INLINE add #-}
  one :: ABP f a -> ABP f a
one = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Backprop a => a -> a
one
  {-# INLINE one #-}

instance (Applicative f, Num a) => Num (ABP f a) where
  + :: ABP f a -> ABP f a -> ABP f a
(+) = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(+)
  {-# INLINE (+) #-}
  (-) = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)
  {-# INLINE (-) #-}
  * :: ABP f a -> ABP f a -> ABP f a
(*) = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Num a => a -> a -> a
(*)
  {-# INLINE (*) #-}
  negate :: ABP f a -> ABP f a
negate = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
negate
  {-# INLINE negate #-}
  abs :: ABP f a -> ABP f a
abs = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
  {-# INLINE abs #-}
  signum :: ABP f a -> ABP f a
signum = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
  {-# INLINE signum #-}
  fromInteger :: Integer -> ABP f a
fromInteger = a -> ABP f a
forall a. a -> ABP f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> ABP f a) -> (Integer -> a) -> Integer -> ABP f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger
  {-# INLINE fromInteger #-}

instance (Applicative f, Fractional a) => Fractional (ABP f a) where
  / :: ABP f a -> ABP f a -> ABP f a
(/) = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
  {-# INLINE (/) #-}
  recip :: ABP f a -> ABP f a
recip = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Fractional a => a -> a
recip
  {-# INLINE recip #-}
  fromRational :: Rational -> ABP f a
fromRational = a -> ABP f a
forall a. a -> ABP f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> ABP f a) -> (Rational -> a) -> Rational -> ABP f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational
  {-# INLINE fromRational #-}

instance (Applicative f, Floating a) => Floating (ABP f a) where
  pi :: ABP f a
pi = a -> ABP f a
forall a. a -> ABP f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Floating a => a
pi
  {-# INLINE pi #-}
  exp :: ABP f a -> ABP f a
exp = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
exp
  {-# INLINE exp #-}
  log :: ABP f a -> ABP f a
log = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
log
  {-# INLINE log #-}
  sqrt :: ABP f a -> ABP f a
sqrt = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sqrt
  {-# INLINE sqrt #-}
  ** :: ABP f a -> ABP f a -> ABP f a
(**) = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
(**)
  {-# INLINE (**) #-}
  logBase :: ABP f a -> ABP f a -> ABP f a
logBase = (a -> a -> a) -> ABP f a -> ABP f a -> ABP f a
forall a b c. (a -> b -> c) -> ABP f a -> ABP f b -> ABP f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Floating a => a -> a -> a
logBase
  {-# INLINE logBase #-}
  sin :: ABP f a -> ABP f a
sin = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sin
  {-# INLINE sin #-}
  cos :: ABP f a -> ABP f a
cos = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cos
  {-# INLINE cos #-}
  tan :: ABP f a -> ABP f a
tan = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tan
  {-# INLINE tan #-}
  asin :: ABP f a -> ABP f a
asin = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asin
  {-# INLINE asin #-}
  acos :: ABP f a -> ABP f a
acos = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acos
  {-# INLINE acos #-}
  atan :: ABP f a -> ABP f a
atan = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atan
  {-# INLINE atan #-}
  sinh :: ABP f a -> ABP f a
sinh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sinh
  {-# INLINE sinh #-}
  cosh :: ABP f a -> ABP f a
cosh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cosh
  {-# INLINE cosh #-}
  tanh :: ABP f a -> ABP f a
tanh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
tanh
  {-# INLINE tanh #-}
  asinh :: ABP f a -> ABP f a
asinh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asinh
  {-# INLINE asinh #-}
  acosh :: ABP f a -> ABP f a
acosh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acosh
  {-# INLINE acosh #-}
  atanh :: ABP f a -> ABP f a
atanh = (a -> a) -> ABP f a -> ABP f a
forall a b. (a -> b) -> ABP f a -> ABP f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atanh
  {-# INLINE atanh #-}

-- | Helper class for automatically deriving 'zero' using GHC Generics.
class GZero f where
  gzero :: f t -> f t

instance Backprop a => GZero (K1 i a) where
  gzero :: forall t. K1 i a t -> K1 i a t
gzero (K1 a
x) = a -> K1 i a t
forall k i c (p :: k). c -> K1 i c p
K1 (a -> a
forall a. Backprop a => a -> a
zero a
x)
  {-# INLINE gzero #-}

instance (GZero f, GZero g) => GZero (f :*: g) where
  gzero :: forall t. (:*:) f g t -> (:*:) f g t
gzero (f t
x :*: g t
y) = f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero f t
x f t -> g t -> (:*:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g t -> g t
forall t. g t -> g t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero g t
y
  {-# INLINE gzero #-}

instance (GZero f, GZero g) => GZero (f :+: g) where
  gzero :: forall t. (:+:) f g t -> (:+:) f g t
gzero (L1 f t
x) = f t -> (:+:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero f t
x)
  gzero (R1 g t
x) = g t -> (:+:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g t -> g t
forall t. g t -> g t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero g t
x)
  {-# INLINE gzero #-}

instance GZero V1 where
  gzero :: forall t. V1 t -> V1 t
gzero = \case {}
  {-# INLINE gzero #-}

instance GZero U1 where
  gzero :: forall t. U1 t -> U1 t
gzero U1 t
_ = U1 t
forall k (p :: k). U1 p
U1
  {-# INLINE gzero #-}

instance GZero f => GZero (M1 i c f) where
  gzero :: forall t. M1 i c f t -> M1 i c f t
gzero (M1 f t
x) = f t -> M1 i c f t
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero f t
x)
  {-# INLINE gzero #-}

instance GZero f => GZero (f :.: g) where
  gzero :: forall t. (:.:) f g t -> (:.:) f g t
gzero (Comp1 f (g t)
x) = f (g t) -> (:.:) f g t
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (f (g t) -> f (g t)
forall t. f t -> f t
forall (f :: * -> *) t. GZero f => f t -> f t
gzero f (g t)
x)
  {-# INLINE gzero #-}

-- | Helper class for automatically deriving 'add' using GHC Generics.
class GAdd f where
  gadd :: f t -> f t -> f t

instance Backprop a => GAdd (K1 i a) where
  gadd :: forall t. K1 i a t -> K1 i a t -> K1 i a t
gadd (K1 a
x) (K1 a
y) = a -> K1 i a t
forall k i c (p :: k). c -> K1 i c p
K1 (a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x a
y)
  {-# INLINE gadd #-}

instance (GAdd f, GAdd g) => GAdd (f :*: g) where
  gadd :: forall t. (:*:) f g t -> (:*:) f g t -> (:*:) f g t
gadd (f t
x1 :*: g t
y1) (f t
x2 :*: g t
y2) = f t
x3 f t -> g t -> (:*:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g t
y3
    where
      !x3 :: f t
x3 = f t -> f t -> f t
forall t. f t -> f t -> f t
forall (f :: * -> *) t. GAdd f => f t -> f t -> f t
gadd f t
x1 f t
x2
      !y3 :: g t
y3 = g t -> g t -> g t
forall t. g t -> g t -> g t
forall (f :: * -> *) t. GAdd f => f t -> f t -> f t
gadd g t
y1 g t
y2
  {-# INLINE gadd #-}

instance GAdd V1 where
  gadd :: forall t. V1 t -> V1 t -> V1 t
gadd = \case {}
  {-# INLINE gadd #-}

instance GAdd U1 where
  gadd :: forall t. U1 t -> U1 t -> U1 t
gadd U1 t
_ U1 t
_ = U1 t
forall k (p :: k). U1 p
U1
  {-# INLINE gadd #-}

instance GAdd f => GAdd (M1 i c f) where
  gadd :: forall t. M1 i c f t -> M1 i c f t -> M1 i c f t
gadd (M1 f t
x) (M1 f t
y) = f t -> M1 i c f t
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (f t -> f t -> f t
forall t. f t -> f t -> f t
forall (f :: * -> *) t. GAdd f => f t -> f t -> f t
gadd f t
x f t
y)
  {-# INLINE gadd #-}

instance GAdd f => GAdd (f :.: g) where
  gadd :: forall t. (:.:) f g t -> (:.:) f g t -> (:.:) f g t
gadd (Comp1 f (g t)
x) (Comp1 f (g t)
y) = f (g t) -> (:.:) f g t
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (f (g t) -> f (g t) -> f (g t)
forall t. f t -> f t -> f t
forall (f :: * -> *) t. GAdd f => f t -> f t -> f t
gadd f (g t)
x f (g t)
y)
  {-# INLINE gadd #-}

-- | Helper class for automatically deriving 'one' using GHC Generics.
class GOne f where
  gone :: f t -> f t

instance Backprop a => GOne (K1 i a) where
  gone :: forall t. K1 i a t -> K1 i a t
gone (K1 a
x) = a -> K1 i a t
forall k i c (p :: k). c -> K1 i c p
K1 (a -> a
forall a. Backprop a => a -> a
one a
x)
  {-# INLINE gone #-}

instance (GOne f, GOne g) => GOne (f :*: g) where
  gone :: forall t. (:*:) f g t -> (:*:) f g t
gone (f t
x :*: g t
y) = f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GOne f => f t -> f t
gone f t
x f t -> g t -> (:*:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g t -> g t
forall t. g t -> g t
forall (f :: * -> *) t. GOne f => f t -> f t
gone g t
y
  {-# INLINE gone #-}

instance (GOne f, GOne g) => GOne (f :+: g) where
  gone :: forall t. (:+:) f g t -> (:+:) f g t
gone (L1 f t
x) = f t -> (:+:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GOne f => f t -> f t
gone f t
x)
  gone (R1 g t
x) = g t -> (:+:) f g t
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g t -> g t
forall t. g t -> g t
forall (f :: * -> *) t. GOne f => f t -> f t
gone g t
x)
  {-# INLINE gone #-}

instance GOne V1 where
  gone :: forall t. V1 t -> V1 t
gone = \case {}
  {-# INLINE gone #-}

instance GOne U1 where
  gone :: forall t. U1 t -> U1 t
gone U1 t
_ = U1 t
forall k (p :: k). U1 p
U1
  {-# INLINE gone #-}

instance GOne f => GOne (M1 i c f) where
  gone :: forall t. M1 i c f t -> M1 i c f t
gone (M1 f t
x) = f t -> M1 i c f t
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (f t -> f t
forall t. f t -> f t
forall (f :: * -> *) t. GOne f => f t -> f t
gone f t
x)
  {-# INLINE gone #-}

instance GOne f => GOne (f :.: g) where
  gone :: forall t. (:.:) f g t -> (:.:) f g t
gone (Comp1 f (g t)
x) = f (g t) -> (:.:) f g t
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (f (g t) -> f (g t)
forall t. f t -> f t
forall (f :: * -> *) t. GOne f => f t -> f t
gone f (g t)
x)
  {-# INLINE gone #-}

instance Backprop Int where
  zero :: Int -> Int
zero = Int -> Int
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Int -> Int -> Int
add = Int -> Int -> Int
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Int -> Int
one = Int -> Int
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance Backprop Integer where
  zero :: Integer -> Integer
zero = Integer -> Integer
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Integer -> Integer -> Integer
add = Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Integer -> Integer
one = Integer -> Integer
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.1.0
instance Backprop Natural where
  zero :: Natural -> Natural
zero = Natural -> Natural
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Natural -> Natural -> Natural
add = Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Natural -> Natural
one = Natural -> Natural
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop Word8 where
  zero :: Word8 -> Word8
zero = Word8 -> Word8
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Word8 -> Word8 -> Word8
add = Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Word8 -> Word8
one = Word8 -> Word8
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop Word where
  zero :: Word -> Word
zero = Word -> Word
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Word -> Word -> Word
add = Word -> Word -> Word
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Word -> Word
one = Word -> Word
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop Word16 where
  zero :: Word16 -> Word16
zero = Word16 -> Word16
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Word16 -> Word16 -> Word16
add = Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Word16 -> Word16
one = Word16 -> Word16
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop Word32 where
  zero :: Word32 -> Word32
zero = Word32 -> Word32
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Word32 -> Word32 -> Word32
add = Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Word32 -> Word32
one = Word32 -> Word32
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop Word64 where
  zero :: Word64 -> Word64
zero = Word64 -> Word64
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Word64 -> Word64 -> Word64
add = Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Word64 -> Word64
one = Word64 -> Word64
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance Integral a => Backprop (Ratio a) where
  zero :: Ratio a -> Ratio a
zero = Ratio a -> Ratio a
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Ratio a -> Ratio a -> Ratio a
add = Ratio a -> Ratio a -> Ratio a
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Ratio a -> Ratio a
one = Ratio a -> Ratio a
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance RealFloat a => Backprop (Complex a) where
  zero :: Complex a -> Complex a
zero = Complex a -> Complex a
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Complex a -> Complex a -> Complex a
add = Complex a -> Complex a -> Complex a
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Complex a -> Complex a
one = Complex a -> Complex a
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance Backprop Float where
  zero :: Float -> Float
zero = Float -> Float
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Float -> Float -> Float
add = Float -> Float -> Float
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Float -> Float
one = Float -> Float
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance Backprop Double where
  zero :: Double -> Double
zero = Double -> Double
forall a. Num a => a -> a
zeroNum
  {-# INLINE zero #-}
  add :: Double -> Double -> Double
add = Double -> Double -> Double
forall a. Num a => a -> a -> a
addNum
  {-# INLINE add #-}
  one :: Double -> Double
one = Double -> Double
forall a. Num a => a -> a
oneNum
  {-# INLINE one #-}

instance Backprop a => Backprop (V.Vector a) where
  zero :: Vector a -> Vector a
zero = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
zeroVec
  {-# INLINE zero #-}
  add :: Vector a -> Vector a -> Vector a
add = Vector a -> Vector a -> Vector a
forall (v :: * -> *) a.
(Vector v a, Backprop a) =>
v a -> v a -> v a
addVec
  {-# INLINE add #-}
  one :: Vector a -> Vector a
one = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
oneVec
  {-# INLINE one #-}

instance (VU.Unbox a, Backprop a) => Backprop (VU.Vector a) where
  zero :: Vector a -> Vector a
zero = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
zeroVec
  {-# INLINE zero #-}
  add :: Vector a -> Vector a -> Vector a
add = Vector a -> Vector a -> Vector a
forall (v :: * -> *) a.
(Vector v a, Backprop a) =>
v a -> v a -> v a
addVec
  {-# INLINE add #-}
  one :: Vector a -> Vector a
one = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
oneVec
  {-# INLINE one #-}

instance (VS.Storable a, Backprop a) => Backprop (VS.Vector a) where
  zero :: Vector a -> Vector a
zero = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
zeroVec
  {-# INLINE zero #-}
  add :: Vector a -> Vector a -> Vector a
add = Vector a -> Vector a -> Vector a
forall (v :: * -> *) a.
(Vector v a, Backprop a) =>
v a -> v a -> v a
addVec
  {-# INLINE add #-}
  one :: Vector a -> Vector a
one = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
oneVec
  {-# INLINE one #-}

instance (VP.Prim a, Backprop a) => Backprop (VP.Vector a) where
  zero :: Vector a -> Vector a
zero = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
zeroVec
  {-# INLINE zero #-}
  add :: Vector a -> Vector a -> Vector a
add = Vector a -> Vector a -> Vector a
forall (v :: * -> *) a.
(Vector v a, Backprop a) =>
v a -> v a -> v a
addVec
  {-# INLINE add #-}
  one :: Vector a -> Vector a
one = Vector a -> Vector a
forall (v :: * -> *) a. (Vector v a, Backprop a) => v a -> v a
oneVec
  {-# INLINE one #-}

-- | 'add' assumes the shorter list has trailing zeroes, and the result has
-- the length of the longest input.
instance Backprop a => Backprop [a] where
  zero :: [a] -> [a]
zero = [a] -> [a]
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: [a] -> [a] -> [a]
add = [a] -> [a] -> [a]
forall a. (IsList a, Backprop (Item a)) => a -> a -> a
addIsList
  {-# INLINE add #-}
  one :: [a] -> [a]
one = [a] -> [a]
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | 'add' assumes the shorter list has trailing zeroes, and the result has
-- the length of the longest input.
instance Backprop a => Backprop (NonEmpty a) where
  zero :: NonEmpty a -> NonEmpty a
zero = NonEmpty a -> NonEmpty a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: NonEmpty a -> NonEmpty a -> NonEmpty a
add = NonEmpty a -> NonEmpty a -> NonEmpty a
forall a. (IsList a, Backprop (Item a)) => a -> a -> a
addIsList
  {-# INLINE add #-}
  one :: NonEmpty a -> NonEmpty a
one = NonEmpty a -> NonEmpty a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | 'add' assumes the shorter sequence has trailing zeroes, and the result
-- has the length of the longest input.
instance Backprop a => Backprop (Seq.Seq a) where
  zero :: Seq a -> Seq a
zero = Seq a -> Seq a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: Seq a -> Seq a -> Seq a
add = Seq a -> Seq a -> Seq a
forall a. (IsList a, Backprop (Item a)) => a -> a -> a
addIsList
  {-# INLINE add #-}
  one :: Seq a -> Seq a
one = Seq a -> Seq a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | 'Nothing' is treated the same as @'Just' 0@.  However, 'zero', 'add',
-- and 'one' preserve 'Nothing' if all inputs are also 'Nothing'.
instance Backprop a => Backprop (Maybe a) where
  zero :: Maybe a -> Maybe a
zero = Maybe a -> Maybe a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: Maybe a -> Maybe a -> Maybe a
add Maybe a
x Maybe a
y = (a -> a -> a
forall a. Backprop a => a -> a -> a
add (a -> a -> a) -> Maybe a -> Maybe (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
x Maybe (a -> a) -> Maybe a -> Maybe a
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe a
y) Maybe a -> Maybe a -> Maybe a
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe a
x Maybe a -> Maybe a -> Maybe a
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe a
y
  {-# INLINE add #-}
  one :: Maybe a -> Maybe a
one = Maybe a -> Maybe a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | 'add' is strict, but 'zero' and 'one' are lazy in their arguments.
instance Backprop () where
  zero :: () -> ()
zero ()
_ = ()
  add :: () -> () -> ()
add () () = ()
  one :: () -> ()
one ()
_ = ()

-- | 'add' is strict
instance (Backprop a, Backprop b) => Backprop (a, b) where
  zero :: (a, b) -> (a, b)
zero (a
x, b
y) = (a -> a
forall a. Backprop a => a -> a
zero a
x, b -> b
forall a. Backprop a => a -> a
zero b
y)
  {-# INLINE zero #-}
  add :: (a, b) -> (a, b) -> (a, b)
add (a
x1, b
y1) (a
x2, b
y2) = (a
x3, b
y3)
    where
      !x3 :: a
x3 = a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x1 a
x2
      !y3 :: b
y3 = b -> b -> b
forall a. Backprop a => a -> a -> a
add b
y1 b
y2
  {-# INLINE add #-}
  one :: (a, b) -> (a, b)
one (a
x, b
y) = (a -> a
forall a. Backprop a => a -> a
one a
x, b -> b
forall a. Backprop a => a -> a
one b
y)
  {-# INLINE one #-}

-- | 'add' is strict
instance (Backprop a, Backprop b, Backprop c) => Backprop (a, b, c) where
  zero :: (a, b, c) -> (a, b, c)
zero (a
x, b
y, c
z) = (a -> a
forall a. Backprop a => a -> a
zero a
x, b -> b
forall a. Backprop a => a -> a
zero b
y, c -> c
forall a. Backprop a => a -> a
zero c
z)
  {-# INLINE zero #-}
  add :: (a, b, c) -> (a, b, c) -> (a, b, c)
add (a
x1, b
y1, c
z1) (a
x2, b
y2, c
z2) = (a
x3, b
y3, c
z3)
    where
      !x3 :: a
x3 = a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x1 a
x2
      !y3 :: b
y3 = b -> b -> b
forall a. Backprop a => a -> a -> a
add b
y1 b
y2
      !z3 :: c
z3 = c -> c -> c
forall a. Backprop a => a -> a -> a
add c
z1 c
z2
  {-# INLINE add #-}
  one :: (a, b, c) -> (a, b, c)
one (a
x, b
y, c
z) = (a -> a
forall a. Backprop a => a -> a
one a
x, b -> b
forall a. Backprop a => a -> a
one b
y, c -> c
forall a. Backprop a => a -> a
one c
z)
  {-# INLINE one #-}

-- | 'add' is strict
instance (Backprop a, Backprop b, Backprop c, Backprop d) => Backprop (a, b, c, d) where
  zero :: (a, b, c, d) -> (a, b, c, d)
zero (a
x, b
y, c
z, d
w) = (a -> a
forall a. Backprop a => a -> a
zero a
x, b -> b
forall a. Backprop a => a -> a
zero b
y, c -> c
forall a. Backprop a => a -> a
zero c
z, d -> d
forall a. Backprop a => a -> a
zero d
w)
  {-# INLINE zero #-}
  add :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)
add (a
x1, b
y1, c
z1, d
w1) (a
x2, b
y2, c
z2, d
w2) = (a
x3, b
y3, c
z3, d
w3)
    where
      !x3 :: a
x3 = a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x1 a
x2
      !y3 :: b
y3 = b -> b -> b
forall a. Backprop a => a -> a -> a
add b
y1 b
y2
      !z3 :: c
z3 = c -> c -> c
forall a. Backprop a => a -> a -> a
add c
z1 c
z2
      !w3 :: d
w3 = d -> d -> d
forall a. Backprop a => a -> a -> a
add d
w1 d
w2
  {-# INLINE add #-}
  one :: (a, b, c, d) -> (a, b, c, d)
one (a
x, b
y, c
z, d
w) = (a -> a
forall a. Backprop a => a -> a
one a
x, b -> b
forall a. Backprop a => a -> a
one b
y, c -> c
forall a. Backprop a => a -> a
one c
z, d -> d
forall a. Backprop a => a -> a
one d
w)
  {-# INLINE one #-}

-- | 'add' is strict
instance (Backprop a, Backprop b, Backprop c, Backprop d, Backprop e) => Backprop (a, b, c, d, e) where
  zero :: (a, b, c, d, e) -> (a, b, c, d, e)
zero (a
x, b
y, c
z, d
w, e
v) = (a -> a
forall a. Backprop a => a -> a
zero a
x, b -> b
forall a. Backprop a => a -> a
zero b
y, c -> c
forall a. Backprop a => a -> a
zero c
z, d -> d
forall a. Backprop a => a -> a
zero d
w, e -> e
forall a. Backprop a => a -> a
zero e
v)
  {-# INLINE zero #-}
  add :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)
add (a
x1, b
y1, c
z1, d
w1, e
v1) (a
x2, b
y2, c
z2, d
w2, e
v2) = (a
x3, b
y3, c
z3, d
w3, e
v3)
    where
      !x3 :: a
x3 = a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x1 a
x2
      !y3 :: b
y3 = b -> b -> b
forall a. Backprop a => a -> a -> a
add b
y1 b
y2
      !z3 :: c
z3 = c -> c -> c
forall a. Backprop a => a -> a -> a
add c
z1 c
z2
      !w3 :: d
w3 = d -> d -> d
forall a. Backprop a => a -> a -> a
add d
w1 d
w2
      !v3 :: e
v3 = e -> e -> e
forall a. Backprop a => a -> a -> a
add e
v1 e
v2
  {-# INLINE add #-}
  one :: (a, b, c, d, e) -> (a, b, c, d, e)
one (a
x, b
y, c
z, d
w, e
v) = (a -> a
forall a. Backprop a => a -> a
one a
x, b -> b
forall a. Backprop a => a -> a
one b
y, c -> c
forall a. Backprop a => a -> a
one c
z, d -> d
forall a. Backprop a => a -> a
one d
w, e -> e
forall a. Backprop a => a -> a
one e
v)
  {-# INLINE one #-}

instance Backprop a => Backprop (Identity a) where
  zero :: Identity a -> Identity a
zero = (a -> a) -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Identity a -> Identity a -> Identity a
add = (a -> a -> a) -> Identity a -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Identity a -> Identity a
one = (a -> a) -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

instance Backprop (Proxy a) where
  zero :: Proxy a -> Proxy a
zero Proxy a
_ = Proxy a
forall {k} (t :: k). Proxy t
Proxy
  {-# INLINE zero #-}
  add :: Proxy a -> Proxy a -> Proxy a
add Proxy a
_ Proxy a
_ = Proxy a
forall {k} (t :: k). Proxy t
Proxy
  {-# INLINE add #-}
  one :: Proxy a -> Proxy a
one Proxy a
_ = Proxy a
forall {k} (t :: k). Proxy t
Proxy
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop w => Backprop (Const w a) where
  zero :: Const w a -> Const w a
zero = (w -> w) -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @w)
  add :: Const w a -> Const w a -> Const w a
add = (w -> w -> w) -> Const w a -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @w)
  one :: Const w a -> Const w a
one = (w -> w) -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @w)

instance Backprop Void where
  zero :: Void -> Void
zero = \case {}
  {-# INLINE zero #-}
  add :: Void -> Void -> Void
add = \case {}
  {-# INLINE add #-}
  one :: Void -> Void
one = \case {}
  {-# INLINE one #-}

-- | 'zero' and 'one' replace all current values, and 'add' merges keys
-- from both maps, adding in the case of double-occurrences.
instance (Backprop a, Ord k) => Backprop (M.Map k a) where
  zero :: Map k a -> Map k a
zero = Map k a -> Map k a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: Map k a -> Map k a -> Map k a
add = (a -> a -> a) -> Map k a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith a -> a -> a
forall a. Backprop a => a -> a -> a
add
  {-# INLINE add #-}
  one :: Map k a -> Map k a
one = Map k a -> Map k a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | 'zero' and 'one' replace all current values, and 'add' merges keys
-- from both maps, adding in the case of double-occurrences.
instance Backprop a => Backprop (IM.IntMap a) where
  zero :: IntMap a -> IntMap a
zero = IntMap a -> IntMap a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: IntMap a -> IntMap a -> IntMap a
add = (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
forall a. (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
IM.unionWith a -> a -> a
forall a. Backprop a => a -> a -> a
add
  {-# INLINE add #-}
  one :: IntMap a -> IntMap a
one = IntMap a -> IntMap a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance Backprop a => Backprop (K1 i a p) where
  zero :: K1 i a p -> K1 i a p
zero = (a -> a) -> K1 i a p -> K1 i a p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: K1 i a p -> K1 i a p -> K1 i a p
add = (a -> a -> a) -> K1 i a p -> K1 i a p -> K1 i a p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: K1 i a p -> K1 i a p
one = (a -> a) -> K1 i a p -> K1 i a p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.2.0
instance Backprop (f p) => Backprop (M1 i c f p) where
  zero :: M1 i c f p -> M1 i c f p
zero = (f p -> f p) -> M1 i c f p -> M1 i c f p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(f p))
  add :: M1 i c f p -> M1 i c f p -> M1 i c f p
add = (f p -> f p -> f p) -> M1 i c f p -> M1 i c f p -> M1 i c f p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(f p))
  one :: M1 i c f p -> M1 i c f p
one = (f p -> f p) -> M1 i c f p -> M1 i c f p
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(f p))

-- | @since 0.2.2.0
instance (Backprop (f p), Backprop (g p)) => Backprop ((f :*: g) p)

-- | @since 0.2.6.3
instance Backprop (f (g a)) => Backprop ((f :.: g) a) where
  zero :: (:.:) f g a -> (:.:) f g a
zero = (f (g a) -> f (g a)) -> (:.:) f g a -> (:.:) f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(f (g a)))
  add :: (:.:) f g a -> (:.:) f g a -> (:.:) f g a
add = (f (g a) -> f (g a) -> f (g a))
-> (:.:) f g a -> (:.:) f g a -> (:.:) f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(f (g a)))
  one :: (:.:) f g a -> (:.:) f g a
one = (f (g a) -> f (g a)) -> (:.:) f g a -> (:.:) f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(f (g a)))

-- | @since 0.2.2.0
instance Backprop (V1 p)

-- | @since 0.2.2.0
instance Backprop (U1 p)

-- | @since 0.2.2.0
instance Backprop a => Backprop (Sum a) where
  zero :: Sum a -> Sum a
zero = (a -> a) -> Sum a -> Sum a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Sum a -> Sum a -> Sum a
add = (a -> a -> a) -> Sum a -> Sum a -> Sum a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Sum a -> Sum a
one = (a -> a) -> Sum a -> Sum a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.2.0
instance Backprop a => Backprop (Product a) where
  zero :: Product a -> Product a
zero = (a -> a) -> Product a -> Product a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Product a -> Product a -> Product a
add = (a -> a -> a) -> Product a -> Product a -> Product a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Product a -> Product a
one = (a -> a) -> Product a -> Product a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

#if !MIN_VERSION_base(4,16,0)
-- | @since 0.2.2.0
instance Backprop a => Backprop (SG.Option a) where
    zero = coerce (zero @(Maybe a))
    add  = coerce (add @(Maybe a))
    one  = coerce (one @(Maybe a))
#endif

-- | @since 0.2.2.0
instance Backprop a => Backprop (SG.First a) where
  zero :: First a -> First a
zero = (a -> a) -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: First a -> First a -> First a
add = (a -> a -> a) -> First a -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: First a -> First a
one = (a -> a) -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.2.0
instance Backprop a => Backprop (SG.Last a) where
  zero :: Last a -> Last a
zero = (a -> a) -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Last a -> Last a -> Last a
add = (a -> a -> a) -> Last a -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Last a -> Last a
one = (a -> a) -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.2.0
instance Backprop a => Backprop (First a) where
  zero :: First a -> First a
zero = (Maybe a -> Maybe a) -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(Maybe a))
  add :: First a -> First a -> First a
add = (Maybe a -> Maybe a -> Maybe a) -> First a -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(Maybe a))
  one :: First a -> First a
one = (Maybe a -> Maybe a) -> First a -> First a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(Maybe a))

-- | @since 0.2.2.0
instance Backprop a => Backprop (Data.Monoid.Last a) where
  zero :: Last a -> Last a
zero = (Maybe a -> Maybe a) -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(Maybe a))
  add :: Last a -> Last a -> Last a
add = (Maybe a -> Maybe a -> Maybe a) -> Last a -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(Maybe a))
  one :: Last a -> Last a
one = (Maybe a -> Maybe a) -> Last a -> Last a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(Maybe a))

-- | @since 0.2.2.0
instance Backprop a => Backprop (Dual a) where
  zero :: Dual a -> Dual a
zero = (a -> a) -> Dual a -> Dual a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Dual a -> Dual a -> Dual a
add = (a -> a -> a) -> Dual a -> Dual a -> Dual a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Dual a -> Dual a
one = (a -> a) -> Dual a -> Dual a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.2.0
instance (Backprop a, Backprop b) => Backprop (SG.Arg a b)

-- | @since 0.2.2.0
instance (Backprop (f a), Backprop (g a)) => Backprop (DFP.Product f g a)

-- | @since 0.2.2.0
instance Backprop (f (g a)) => Backprop (Compose f g a) where
  zero :: Compose f g a -> Compose f g a
zero = (f (g a) -> f (g a)) -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(f (g a)))
  add :: Compose f g a -> Compose f g a -> Compose f g a
add = (f (g a) -> f (g a) -> f (g a))
-> Compose f g a -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(f (g a)))
  one :: Compose f g a -> Compose f g a
one = (f (g a) -> f (g a)) -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(f (g a)))

-- | 'add' adds together results; 'zero' and 'one' act on results.
--
-- @since 0.2.2.0
instance Backprop a => Backprop (r -> a) where
  zero :: (r -> a) -> r -> a
zero = (r -> a) -> r -> a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
zeroFunctor
  {-# INLINE zero #-}
  add :: (r -> a) -> (r -> a) -> r -> a
add = (a -> a -> a) -> (r -> a) -> (r -> a) -> r -> a
forall a b c. (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Backprop a => a -> a -> a
add
  {-# INLINE add #-}
  one :: (r -> a) -> r -> a
one = (r -> a) -> r -> a
forall (f :: * -> *) a. (Functor f, Backprop a) => f a -> f a
oneFunctor
  {-# INLINE one #-}

-- | @since 0.2.2.0
instance (Backprop a, Applicative m) => Backprop (Arr.Kleisli m r a) where
  zero :: Kleisli m r a -> Kleisli m r a
zero (Arr.Kleisli r -> m a
f) = (r -> m a) -> Kleisli m r a
forall (m :: * -> *) a b. (a -> m b) -> Kleisli m a b
Arr.Kleisli (((m a -> m a) -> (r -> m a) -> r -> m a
forall a b. (a -> b) -> (r -> a) -> r -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((m a -> m a) -> (r -> m a) -> r -> m a)
-> ((a -> a) -> m a -> m a) -> (a -> a) -> (r -> m a) -> r -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a) -> m a -> m a
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) a -> a
forall a. Backprop a => a -> a
zero r -> m a
f)
  {-# INLINE zero #-}
  add :: Kleisli m r a -> Kleisli m r a -> Kleisli m r a
add (Arr.Kleisli r -> m a
f) (Arr.Kleisli r -> m a
g) = (r -> m a) -> Kleisli m r a
forall (m :: * -> *) a b. (a -> m b) -> Kleisli m a b
Arr.Kleisli ((r -> m a) -> Kleisli m r a) -> (r -> m a) -> Kleisli m r a
forall a b. (a -> b) -> a -> b
$ \r
x ->
    a -> a -> a
forall a. Backprop a => a -> a -> a
add (a -> a -> a) -> m a -> m (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> r -> m a
f r
x m (a -> a) -> m a -> m a
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> r -> m a
g r
x
  {-# INLINE add #-}
  one :: Kleisli m r a -> Kleisli m r a
one (Arr.Kleisli r -> m a
f) = (r -> m a) -> Kleisli m r a
forall (m :: * -> *) a b. (a -> m b) -> Kleisli m a b
Arr.Kleisli (((m a -> m a) -> (r -> m a) -> r -> m a
forall a b. (a -> b) -> (r -> a) -> r -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((m a -> m a) -> (r -> m a) -> r -> m a)
-> ((a -> a) -> m a -> m a) -> (a -> a) -> (r -> m a) -> r -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a) -> m a -> m a
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) a -> a
forall a. Backprop a => a -> a
one r -> m a
f)
  {-# INLINE one #-}

-- | @since 0.2.6.3
instance (ReifyConstraint Backprop f rs, RMap rs, RApply rs) => Backprop (Rec f rs) where
  zero :: Rec f rs -> Rec f rs
zero =
    (forall x. (:.) (Dict Backprop) f x -> f x)
-> Rec (Dict Backprop :. f) rs -> Rec f rs
forall {u} (rs :: [u]) (f :: u -> *) (g :: u -> *).
RMap rs =>
(forall (x :: u). f x -> g x) -> Rec f rs -> Rec g rs
forall (f :: * -> *) (g :: * -> *).
(forall x. f x -> g x) -> Rec f rs -> Rec g rs
rmap (\case V.Compose (Dict f x
x) -> f x -> f x
forall a. Backprop a => a -> a
zero f x
x)
      (Rec (Dict Backprop :. f) rs -> Rec f rs)
-> (Rec f rs -> Rec (Dict Backprop :. f) rs)
-> Rec f rs
-> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {u} (c :: * -> Constraint) (f :: u -> *) (rs :: [u]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
forall (c :: * -> Constraint) (f :: * -> *) (rs :: [*]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
reifyConstraint @Backprop
  {-# INLINE zero #-}
  add :: Rec f rs -> Rec f rs -> Rec f rs
add Rec f rs
xs =
    (forall x. f x -> (:.) (Dict Backprop) f x -> f x)
-> Rec f rs -> Rec (Dict Backprop :. f) rs -> Rec f rs
forall {u} (xs :: [u]) (f :: u -> *) (g :: u -> *) (h :: u -> *).
(RMap xs, RApply xs) =>
(forall (x :: u). f x -> g x -> h x)
-> Rec f xs -> Rec g xs -> Rec h xs
rzipWith (\f x
x -> \case V.Compose (Dict f x
y) -> f x -> f x -> f x
forall a. Backprop a => a -> a -> a
add f x
x f x
y) Rec f rs
xs
      (Rec (Dict Backprop :. f) rs -> Rec f rs)
-> (Rec f rs -> Rec (Dict Backprop :. f) rs)
-> Rec f rs
-> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {u} (c :: * -> Constraint) (f :: u -> *) (rs :: [u]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
forall (c :: * -> Constraint) (f :: * -> *) (rs :: [*]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
reifyConstraint @Backprop
  {-# INLINE add #-}
  one :: Rec f rs -> Rec f rs
one =
    (forall x. (:.) (Dict Backprop) f x -> f x)
-> Rec (Dict Backprop :. f) rs -> Rec f rs
forall {u} (rs :: [u]) (f :: u -> *) (g :: u -> *).
RMap rs =>
(forall (x :: u). f x -> g x) -> Rec f rs -> Rec g rs
forall (f :: * -> *) (g :: * -> *).
(forall x. f x -> g x) -> Rec f rs -> Rec g rs
rmap (\case V.Compose (Dict f x
x) -> f x -> f x
forall a. Backprop a => a -> a
one f x
x)
      (Rec (Dict Backprop :. f) rs -> Rec f rs)
-> (Rec f rs -> Rec (Dict Backprop :. f) rs)
-> Rec f rs
-> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {u} (c :: * -> Constraint) (f :: u -> *) (rs :: [u]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
forall (c :: * -> Constraint) (f :: * -> *) (rs :: [*]).
ReifyConstraint c f rs =>
Rec f rs -> Rec (Dict c :. f) rs
reifyConstraint @Backprop
  {-# INLINE one #-}

-- | @since 0.2.6.3
#if MIN_VERSION_vinyl(0,14,2)
instance (ReifyConstraint Backprop f rs, RMap rs, RApply rs, RecApplicative rs, NatToInt (RLength rs), RPureConstrained (IndexableField rs) rs, ToARec rs)
      => Backprop (ARec f rs) where
    zero :: ARec f rs -> ARec f rs
zero = Rec f rs -> ARec f rs
forall {k} (f :: k -> *) (ts :: [k]).
(NatToInt (RLength ts), ToARec ts) =>
Rec f ts -> ARec f ts
toARec (Rec f rs -> ARec f rs)
-> (ARec f rs -> Rec f rs) -> ARec f rs -> ARec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (ARec f rs -> Rec f rs) -> ARec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ARec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
(RecApplicative ts, RPureConstrained (IndexableField ts) ts) =>
ARec f ts -> Rec f ts
fromARec
    {-# INLINE zero #-}
    add :: ARec f rs -> ARec f rs -> ARec f rs
add ARec f rs
xs ARec f rs
ys = Rec f rs -> ARec f rs
forall {k} (f :: k -> *) (ts :: [k]).
(NatToInt (RLength ts), ToARec ts) =>
Rec f ts -> ARec f ts
toARec (Rec f rs -> ARec f rs) -> Rec f rs -> ARec f rs
forall a b. (a -> b) -> a -> b
$ Rec f rs -> Rec f rs -> Rec f rs
forall a. Backprop a => a -> a -> a
add (ARec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
(RecApplicative ts, RPureConstrained (IndexableField ts) ts) =>
ARec f ts -> Rec f ts
fromARec ARec f rs
xs) (ARec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
(RecApplicative ts, RPureConstrained (IndexableField ts) ts) =>
ARec f ts -> Rec f ts
fromARec ARec f rs
ys)
    {-# INLINE add #-}
    one :: ARec f rs -> ARec f rs
one  = Rec f rs -> ARec f rs
forall {k} (f :: k -> *) (ts :: [k]).
(NatToInt (RLength ts), ToARec ts) =>
Rec f ts -> ARec f ts
toARec (Rec f rs -> ARec f rs)
-> (ARec f rs -> Rec f rs) -> ARec f rs -> ARec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (ARec f rs -> Rec f rs) -> ARec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ARec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
(RecApplicative ts, RPureConstrained (IndexableField ts) ts) =>
ARec f ts -> Rec f ts
fromARec
    {-# INLINE one #-}
#else
instance (ReifyConstraint Backprop f rs, RMap rs, RApply rs, RecApplicative rs, NatToInt (RLength rs), RPureConstrained (IndexableField rs) rs)
      => Backprop (ARec f rs) where
    zero = toARec . zero . fromARec
    {-# INLINE zero #-}
    add xs ys = toARec $ add (fromARec xs) (fromARec ys)
    {-# INLINE add #-}
    one  = toARec . zero . fromARec
    {-# INLINE one #-}
#endif

-- | @since 0.2.6.3
instance
  (ReifyConstraint Backprop f rs, RMap rs, RApply rs, VS.Storable (Rec f rs)) =>
  Backprop (SRec f rs)
  where
  zero :: SRec f rs -> SRec f rs
zero = Rec f rs -> SRec f rs
forall {k} (f :: k -> *) (ts :: [k]).
Storable (Rec f ts) =>
Rec f ts -> SRec f ts
toSRec (Rec f rs -> SRec f rs)
-> (SRec f rs -> Rec f rs) -> SRec f rs -> SRec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (SRec f rs -> Rec f rs) -> SRec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
Storable (Rec f ts) =>
SRec f ts -> Rec f ts
fromSRec
  {-# INLINE zero #-}
  add :: SRec f rs -> SRec f rs -> SRec f rs
add SRec f rs
xs SRec f rs
ys = Rec f rs -> SRec f rs
forall {k} (f :: k -> *) (ts :: [k]).
Storable (Rec f ts) =>
Rec f ts -> SRec f ts
toSRec (Rec f rs -> SRec f rs) -> Rec f rs -> SRec f rs
forall a b. (a -> b) -> a -> b
$ Rec f rs -> Rec f rs -> Rec f rs
forall a. Backprop a => a -> a -> a
add (SRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
Storable (Rec f ts) =>
SRec f ts -> Rec f ts
fromSRec SRec f rs
xs) (SRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
Storable (Rec f ts) =>
SRec f ts -> Rec f ts
fromSRec SRec f rs
ys)
  {-# INLINE add #-}
  one :: SRec f rs -> SRec f rs
one = Rec f rs -> SRec f rs
forall {k} (f :: k -> *) (ts :: [k]).
Storable (Rec f ts) =>
Rec f ts -> SRec f ts
toSRec (Rec f rs -> SRec f rs)
-> (SRec f rs -> Rec f rs) -> SRec f rs -> SRec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (SRec f rs -> Rec f rs) -> SRec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
Storable (Rec f ts) =>
SRec f ts -> Rec f ts
fromSRec
  {-# INLINE one #-}

-- | @since 0.2.6.3
instance
  (ReifyConstraint Backprop f rs, RMap rs, RApply rs, IsoXRec f rs) =>
  Backprop (XRec f rs)
  where
  zero :: XRec f rs -> XRec f rs
zero = Rec f rs -> XRec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
Rec f ts -> XRec f ts
toXRec (Rec f rs -> XRec f rs)
-> (XRec f rs -> Rec f rs) -> XRec f rs -> XRec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (XRec f rs -> Rec f rs) -> XRec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
XRec f ts -> Rec f ts
fromXRec
  {-# INLINE zero #-}
  add :: XRec f rs -> XRec f rs -> XRec f rs
add XRec f rs
xs XRec f rs
ys = Rec f rs -> XRec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
Rec f ts -> XRec f ts
toXRec (Rec f rs -> XRec f rs) -> Rec f rs -> XRec f rs
forall a b. (a -> b) -> a -> b
$ Rec f rs -> Rec f rs -> Rec f rs
forall a. Backprop a => a -> a -> a
add (XRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
XRec f ts -> Rec f ts
fromXRec XRec f rs
xs) (XRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
XRec f ts -> Rec f ts
fromXRec XRec f rs
ys)
  {-# INLINE add #-}
  one :: XRec f rs -> XRec f rs
one = Rec f rs -> XRec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
Rec f ts -> XRec f ts
toXRec (Rec f rs -> XRec f rs)
-> (XRec f rs -> Rec f rs) -> XRec f rs -> XRec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec f rs -> Rec f rs
forall a. Backprop a => a -> a
zero (Rec f rs -> Rec f rs)
-> (XRec f rs -> Rec f rs) -> XRec f rs -> Rec f rs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XRec f rs -> Rec f rs
forall {u} (f :: u -> *) (ts :: [u]).
IsoXRec f ts =>
XRec f ts -> Rec f ts
fromXRec
  {-# INLINE one #-}

-- | @since 0.2.6.3
instance Backprop a => Backprop (V.Identity a) where
  zero :: Identity a -> Identity a
zero = (a -> a) -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @a)
  add :: Identity a -> Identity a -> Identity a
add = (a -> a -> a) -> Identity a -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @a)
  one :: Identity a -> Identity a
one = (a -> a) -> Identity a -> Identity a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @a)

-- | @since 0.2.6.3
instance Backprop a => Backprop (V.Thunk a) where
  zero :: Thunk a -> Thunk a
zero (V.Thunk a
x) = a -> Thunk a
forall a. a -> Thunk a
V.Thunk (a -> a
forall a. Backprop a => a -> a
zero a
x)
  add :: Thunk a -> Thunk a -> Thunk a
add (V.Thunk a
x) (V.Thunk a
y) = a -> Thunk a
forall a. a -> Thunk a
V.Thunk (a -> a -> a
forall a. Backprop a => a -> a -> a
add a
x a
y)
  one :: Thunk a -> Thunk a
one (V.Thunk a
x) = a -> Thunk a
forall a. a -> Thunk a
V.Thunk (a -> a
forall a. Backprop a => a -> a
one a
x)

-- | @since 0.2.6.3
instance Backprop (op (f a) (g a)) => Backprop (V.Lift op f g a) where
  zero :: Lift op f g a -> Lift op f g a
zero = (op (f a) (g a) -> op (f a) (g a))
-> Lift op f g a -> Lift op f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(op (f a) (g a)))
  add :: Lift op f g a -> Lift op f g a -> Lift op f g a
add = (op (f a) (g a) -> op (f a) (g a) -> op (f a) (g a))
-> Lift op f g a -> Lift op f g a -> Lift op f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(op (f a) (g a)))
  one :: Lift op f g a -> Lift op f g a
one = (op (f a) (g a) -> op (f a) (g a))
-> Lift op f g a -> Lift op f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(op (f a) (g a)))

-- | @since 0.2.6.3
instance Backprop t => Backprop (V.ElField '(s, t)) where
  zero :: ElField '(s, t) -> ElField '(s, t)
zero (V.Field Snd '(s, t)
x) = Snd '(s, t) -> ElField '(s, t)
forall (t :: (Symbol, *)). Snd t -> ElField t
V.Field (t -> t
forall a. Backprop a => a -> a
zero t
Snd '(s, t)
x)
  add :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t)
add (V.Field Snd '(s, t)
x) (V.Field Snd '(s, t)
y) = Snd '(s, t) -> ElField '(s, t)
forall (t :: (Symbol, *)). Snd t -> ElField t
V.Field (t -> t -> t
forall a. Backprop a => a -> a -> a
add t
Snd '(s, t)
x t
Snd '(s, t)
y)
  one :: ElField '(s, t) -> ElField '(s, t)
one (V.Field Snd '(s, t)
x) = Snd '(s, t) -> ElField '(s, t)
forall (t :: (Symbol, *)). Snd t -> ElField t
V.Field (t -> t
forall a. Backprop a => a -> a
one t
Snd '(s, t)
x)

-- | @since 0.2.6.3
instance Backprop (f (g a)) => Backprop (V.Compose f g a) where
  zero :: Compose f g a -> Compose f g a
zero = (f (g a) -> f (g a)) -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(f (g a)))
  add :: Compose f g a -> Compose f g a -> Compose f g a
add = (f (g a) -> f (g a) -> f (g a))
-> Compose f g a -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(f (g a)))
  one :: Compose f g a -> Compose f g a
one = (f (g a) -> f (g a)) -> Compose f g a -> Compose f g a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(f (g a)))

-- | @since 0.2.6.3
instance Backprop w => Backprop (V.Const w a) where
  zero :: Const w a -> Const w a
zero = (w -> w) -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @w)
  add :: Const w a -> Const w a -> Const w a
add = (w -> w -> w) -> Const w a -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @w)
  one :: Const w a -> Const w a
one = (w -> w) -> Const w a -> Const w a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @w)

-- | @since 0.2.6.3
instance Backprop (V.HKD t a) => Backprop (V.XData t a) where
  zero :: XData t a -> XData t a
zero = (HKD t a -> HKD t a) -> XData t a -> XData t a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
zero @(V.HKD t a))
  add :: XData t a -> XData t a -> XData t a
add = (HKD t a -> HKD t a -> HKD t a)
-> XData t a -> XData t a -> XData t a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a -> a
add @(V.HKD t a))
  one :: XData t a -> XData t a
one = (HKD t a -> HKD t a) -> XData t a -> XData t a
forall a b. Coercible a b => a -> b
coerce (forall a. Backprop a => a -> a
one @(V.HKD t a))

-- | @since 0.2.6.3
instance Backprop (SField field) where
  zero :: SField field -> SField field
zero SField field
_ = SField field
forall k (field :: k). SField field
SField
  add :: SField field -> SField field -> SField field
add SField field
_ SField field
_ = SField field
forall k (field :: k). SField field
SField
  one :: SField field -> SField field
one SField field
_ = SField field
forall k (field :: k). SField field
SField

-- | @since 0.2.6.3
instance Backprop (Label field) where
  zero :: Label field -> Label field
zero Label field
_ = Label field
forall (a :: Symbol). Label a
Label
  add :: Label field -> Label field -> Label field
add Label field
_ Label field
_ = Label field
forall (a :: Symbol). Label a
Label
  one :: Label field -> Label field
one Label field
_ = Label field
forall (a :: Symbol). Label a
Label