{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Copyright   :  (c) Edward Kmett 2010-2021
-- License     :  BSD3
-- Maintainer  :  ekmett@gmail.com
-- Stability   :  experimental
-- Portability :  GHC only
--
-----------------------------------------------------------------------------
module Numeric.AD.Internal.Identity
  ( Id(..)
  , probe
  , unprobe
  , probed
  , unprobed
  ) where

import Data.Data (Data)
#if !(MIN_VERSION_base(4,11,0))
import Data.Semigroup (Semigroup(..))
#endif
import Data.Number.Erf
import Data.Typeable (Typeable)
import Numeric.AD.Mode

newtype Id a = Id { forall a. Id a -> a
runId :: a } deriving
  ( Id a -> Id a -> Bool
forall a. Eq a => Id a -> Id a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Id a -> Id a -> Bool
$c/= :: forall a. Eq a => Id a -> Id a -> Bool
== :: Id a -> Id a -> Bool
$c== :: forall a. Eq a => Id a -> Id a -> Bool
Eq, Id a -> Id a -> Bool
Id a -> Id a -> Ordering
Id a -> Id a -> Id 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 (Id a)
forall a. Ord a => Id a -> Id a -> Bool
forall a. Ord a => Id a -> Id a -> Ordering
forall a. Ord a => Id a -> Id a -> Id a
min :: Id a -> Id a -> Id a
$cmin :: forall a. Ord a => Id a -> Id a -> Id a
max :: Id a -> Id a -> Id a
$cmax :: forall a. Ord a => Id a -> Id a -> Id a
>= :: Id a -> Id a -> Bool
$c>= :: forall a. Ord a => Id a -> Id a -> Bool
> :: Id a -> Id a -> Bool
$c> :: forall a. Ord a => Id a -> Id a -> Bool
<= :: Id a -> Id a -> Bool
$c<= :: forall a. Ord a => Id a -> Id a -> Bool
< :: Id a -> Id a -> Bool
$c< :: forall a. Ord a => Id a -> Id a -> Bool
compare :: Id a -> Id a -> Ordering
$ccompare :: forall a. Ord a => Id a -> Id a -> Ordering
Ord, Int -> Id a -> ShowS
forall a. Show a => Int -> Id a -> ShowS
forall a. Show a => [Id a] -> ShowS
forall a. Show a => Id a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Id a] -> ShowS
$cshowList :: forall a. Show a => [Id a] -> ShowS
show :: Id a -> String
$cshow :: forall a. Show a => Id a -> String
showsPrec :: Int -> Id a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Id a -> ShowS
Show, Int -> Id a
Id a -> Int
Id a -> [Id a]
Id a -> Id a
Id a -> Id a -> [Id a]
Id a -> Id a -> Id a -> [Id a]
forall a. Enum a => Int -> Id a
forall a. Enum a => Id a -> Int
forall a. Enum a => Id a -> [Id a]
forall a. Enum a => Id a -> Id a
forall a. Enum a => Id a -> Id a -> [Id a]
forall a. Enum a => Id a -> Id a -> Id a -> [Id a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Id a -> Id a -> Id a -> [Id a]
$cenumFromThenTo :: forall a. Enum a => Id a -> Id a -> Id a -> [Id a]
enumFromTo :: Id a -> Id a -> [Id a]
$cenumFromTo :: forall a. Enum a => Id a -> Id a -> [Id a]
enumFromThen :: Id a -> Id a -> [Id a]
$cenumFromThen :: forall a. Enum a => Id a -> Id a -> [Id a]
enumFrom :: Id a -> [Id a]
$cenumFrom :: forall a. Enum a => Id a -> [Id a]
fromEnum :: Id a -> Int
$cfromEnum :: forall a. Enum a => Id a -> Int
toEnum :: Int -> Id a
$ctoEnum :: forall a. Enum a => Int -> Id a
pred :: Id a -> Id a
$cpred :: forall a. Enum a => Id a -> Id a
succ :: Id a -> Id a
$csucc :: forall a. Enum a => Id a -> Id a
Enum, Id a
forall a. a -> a -> Bounded a
forall a. Bounded a => Id a
maxBound :: Id a
$cmaxBound :: forall a. Bounded a => Id a
minBound :: Id a
$cminBound :: forall a. Bounded a => Id a
Bounded
  , Integer -> Id a
Id a -> Id a
Id a -> Id a -> Id a
forall a. Num a => Integer -> Id a
forall a. Num a => Id a -> Id a
forall a. Num a => Id a -> Id a -> Id a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Id a
$cfromInteger :: forall a. Num a => Integer -> Id a
signum :: Id a -> Id a
$csignum :: forall a. Num a => Id a -> Id a
abs :: Id a -> Id a
$cabs :: forall a. Num a => Id a -> Id a
negate :: Id a -> Id a
$cnegate :: forall a. Num a => Id a -> Id a
* :: Id a -> Id a -> Id a
$c* :: forall a. Num a => Id a -> Id a -> Id a
- :: Id a -> Id a -> Id a
$c- :: forall a. Num a => Id a -> Id a -> Id a
+ :: Id a -> Id a -> Id a
$c+ :: forall a. Num a => Id a -> Id a -> Id a
Num, Id a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall {a}. Real a => Num (Id a)
forall {a}. Real a => Ord (Id a)
forall a. Real a => Id a -> Rational
toRational :: Id a -> Rational
$ctoRational :: forall a. Real a => Id a -> Rational
Real, Rational -> Id a
Id a -> Id a
Id a -> Id a -> Id a
forall {a}. Fractional a => Num (Id a)
forall a. Fractional a => Rational -> Id a
forall a. Fractional a => Id a -> Id a
forall a. Fractional a => Id a -> Id a -> Id a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Id a
$cfromRational :: forall a. Fractional a => Rational -> Id a
recip :: Id a -> Id a
$crecip :: forall a. Fractional a => Id a -> Id a
/ :: Id a -> Id a -> Id a
$c/ :: forall a. Fractional a => Id a -> Id a -> Id a
Fractional, Id a
Id a -> Id a
Id a -> Id a -> Id a
forall {a}. Floating a => Fractional (Id a)
forall a. Floating a => Id a
forall a. Floating a => Id a -> Id a
forall a. Floating a => Id a -> Id a -> Id 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
log1mexp :: Id a -> Id a
$clog1mexp :: forall a. Floating a => Id a -> Id a
log1pexp :: Id a -> Id a
$clog1pexp :: forall a. Floating a => Id a -> Id a
expm1 :: Id a -> Id a
$cexpm1 :: forall a. Floating a => Id a -> Id a
log1p :: Id a -> Id a
$clog1p :: forall a. Floating a => Id a -> Id a
atanh :: Id a -> Id a
$catanh :: forall a. Floating a => Id a -> Id a
acosh :: Id a -> Id a
$cacosh :: forall a. Floating a => Id a -> Id a
asinh :: Id a -> Id a
$casinh :: forall a. Floating a => Id a -> Id a
tanh :: Id a -> Id a
$ctanh :: forall a. Floating a => Id a -> Id a
cosh :: Id a -> Id a
$ccosh :: forall a. Floating a => Id a -> Id a
sinh :: Id a -> Id a
$csinh :: forall a. Floating a => Id a -> Id a
atan :: Id a -> Id a
$catan :: forall a. Floating a => Id a -> Id a
acos :: Id a -> Id a
$cacos :: forall a. Floating a => Id a -> Id a
asin :: Id a -> Id a
$casin :: forall a. Floating a => Id a -> Id a
tan :: Id a -> Id a
$ctan :: forall a. Floating a => Id a -> Id a
cos :: Id a -> Id a
$ccos :: forall a. Floating a => Id a -> Id a
sin :: Id a -> Id a
$csin :: forall a. Floating a => Id a -> Id a
logBase :: Id a -> Id a -> Id a
$clogBase :: forall a. Floating a => Id a -> Id a -> Id a
** :: Id a -> Id a -> Id a
$c** :: forall a. Floating a => Id a -> Id a -> Id a
sqrt :: Id a -> Id a
$csqrt :: forall a. Floating a => Id a -> Id a
log :: Id a -> Id a
$clog :: forall a. Floating a => Id a -> Id a
exp :: Id a -> Id a
$cexp :: forall a. Floating a => Id a -> Id a
pi :: Id a
$cpi :: forall a. Floating a => Id a
Floating
  , forall b. Integral b => Id a -> b
forall b. Integral b => Id a -> (b, Id a)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall {a}. RealFrac a => Fractional (Id a)
forall {a}. RealFrac a => Real (Id a)
forall a b. (RealFrac a, Integral b) => Id a -> b
forall a b. (RealFrac a, Integral b) => Id a -> (b, Id a)
floor :: forall b. Integral b => Id a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Id a -> b
ceiling :: forall b. Integral b => Id a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Id a -> b
round :: forall b. Integral b => Id a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Id a -> b
truncate :: forall b. Integral b => Id a -> b
$ctruncate :: forall a b. (RealFrac a, Integral b) => Id a -> b
properFraction :: forall b. Integral b => Id a -> (b, Id a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => Id a -> (b, Id a)
RealFrac, Int -> Id a -> Id a
Integer -> Int -> Id a
Id a -> Bool
Id a -> Int
Id a -> Integer
Id a -> (Int, Int)
Id a -> (Integer, Int)
Id a -> Id a
Id a -> Id a -> Id a
forall {a}. RealFloat a => Floating (Id a)
forall {a}. RealFloat a => RealFrac (Id a)
forall a. RealFloat a => Int -> Id a -> Id a
forall a. RealFloat a => Integer -> Int -> Id a
forall a. RealFloat a => Id a -> Bool
forall a. RealFloat a => Id a -> Int
forall a. RealFloat a => Id a -> Integer
forall a. RealFloat a => Id a -> (Int, Int)
forall a. RealFloat a => Id a -> (Integer, Int)
forall a. RealFloat a => Id a -> Id a
forall a. RealFloat a => Id a -> Id a -> Id a
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Id a -> Id a -> Id a
$catan2 :: forall a. RealFloat a => Id a -> Id a -> Id a
isIEEE :: Id a -> Bool
$cisIEEE :: forall a. RealFloat a => Id a -> Bool
isNegativeZero :: Id a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Id a -> Bool
isDenormalized :: Id a -> Bool
$cisDenormalized :: forall a. RealFloat a => Id a -> Bool
isInfinite :: Id a -> Bool
$cisInfinite :: forall a. RealFloat a => Id a -> Bool
isNaN :: Id a -> Bool
$cisNaN :: forall a. RealFloat a => Id a -> Bool
scaleFloat :: Int -> Id a -> Id a
$cscaleFloat :: forall a. RealFloat a => Int -> Id a -> Id a
significand :: Id a -> Id a
$csignificand :: forall a. RealFloat a => Id a -> Id a
exponent :: Id a -> Int
$cexponent :: forall a. RealFloat a => Id a -> Int
encodeFloat :: Integer -> Int -> Id a
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Id a
decodeFloat :: Id a -> (Integer, Int)
$cdecodeFloat :: forall a. RealFloat a => Id a -> (Integer, Int)
floatRange :: Id a -> (Int, Int)
$cfloatRange :: forall a. RealFloat a => Id a -> (Int, Int)
floatDigits :: Id a -> Int
$cfloatDigits :: forall a. RealFloat a => Id a -> Int
floatRadix :: Id a -> Integer
$cfloatRadix :: forall a. RealFloat a => Id a -> Integer
RealFloat, NonEmpty (Id a) -> Id a
Id a -> Id a -> Id a
forall b. Integral b => b -> Id a -> Id a
forall a. Semigroup a => NonEmpty (Id a) -> Id a
forall a. Semigroup a => Id a -> Id a -> Id a
forall a b. (Semigroup a, Integral b) => b -> Id a -> Id a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: forall b. Integral b => b -> Id a -> Id a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Id a -> Id a
sconcat :: NonEmpty (Id a) -> Id a
$csconcat :: forall a. Semigroup a => NonEmpty (Id a) -> Id a
<> :: Id a -> Id a -> Id a
$c<> :: forall a. Semigroup a => Id a -> Id a -> Id a
Semigroup
  , Id a
[Id a] -> Id a
Id a -> Id a -> Id a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall {a}. Monoid a => Semigroup (Id a)
forall a. Monoid a => Id a
forall a. Monoid a => [Id a] -> Id a
forall a. Monoid a => Id a -> Id a -> Id a
mconcat :: [Id a] -> Id a
$cmconcat :: forall a. Monoid a => [Id a] -> Id a
mappend :: Id a -> Id a -> Id a
$cmappend :: forall a. Monoid a => Id a -> Id a -> Id a
mempty :: Id a
$cmempty :: forall a. Monoid a => Id a
Monoid, Id a -> DataType
Id a -> Constr
forall {a}. Data a => Typeable (Id a)
forall a. Data a => Id a -> DataType
forall a. Data a => Id a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> Id a -> Id a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Id a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Id a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id 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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Id a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Id a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Id a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Id a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
gmapT :: (forall b. Data b => b -> b) -> Id a -> Id a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Id a -> Id a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
dataTypeOf :: Id a -> DataType
$cdataTypeOf :: forall a. Data a => Id a -> DataType
toConstr :: Id a -> Constr
$ctoConstr :: forall a. Data a => Id a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
Data, Typeable, Id a -> Id a
forall a.
Floating a -> (a -> a) -> (a -> a) -> (a -> a) -> (a -> a) -> Erf a
forall {a}. Erf a => Floating (Id a)
forall a. Erf a => Id a -> Id a
normcdf :: Id a -> Id a
$cnormcdf :: forall a. Erf a => Id a -> Id a
erfcx :: Id a -> Id a
$cerfcx :: forall a. Erf a => Id a -> Id a
erfc :: Id a -> Id a
$cerfc :: forall a. Erf a => Id a -> Id a
erf :: Id a -> Id a
$cerf :: forall a. Erf a => Id a -> Id a
Erf, Id a -> Id a
forall a.
Floating a -> (a -> a) -> (a -> a) -> (a -> a) -> InvErf a
forall {a}. InvErf a => Floating (Id a)
forall a. InvErf a => Id a -> Id a
invnormcdf :: Id a -> Id a
$cinvnormcdf :: forall a. InvErf a => Id a -> Id a
inverfc :: Id a -> Id a
$cinverfc :: forall a. InvErf a => Id a -> Id a
inverf :: Id a -> Id a
$cinverf :: forall a. InvErf a => Id a -> Id a
InvErf
  )

probe :: a -> Id a
probe :: forall a. a -> Id a
probe = forall a. a -> Id a
Id

unprobe :: Id a -> a
unprobe :: forall a. Id a -> a
unprobe = forall a. Id a -> a
runId

pid :: Functor f => f a -> f (Id a)
pid :: forall (f :: * -> *) a. Functor f => f a -> f (Id a)
pid = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Id a
probe

unpid :: Functor f => f (Id a) -> f a
unpid :: forall (f :: * -> *) a. Functor f => f (Id a) -> f a
unpid = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Id a -> a
unprobe

probed :: Functor f => f a -> f (Id a)
probed :: forall (f :: * -> *) a. Functor f => f a -> f (Id a)
probed = forall (f :: * -> *) a. Functor f => f a -> f (Id a)
pid

unprobed :: Functor f => f (Id a) -> f a
unprobed :: forall (f :: * -> *) a. Functor f => f (Id a) -> f a
unprobed = forall (f :: * -> *) a. Functor f => f (Id a) -> f a
unpid

instance Num a => Mode (Id a) where
  type Scalar (Id a) = a
  auto :: Scalar (Id a) -> Id a
auto = forall a. a -> Id a
Id
  Id a
a ^* :: Id a -> Scalar (Id a) -> Id a
^* Scalar (Id a)
b = forall a. a -> Id a
Id (a
a forall a. Num a => a -> a -> a
* Scalar (Id a)
b)
  Scalar (Id a)
a *^ :: Scalar (Id a) -> Id a -> Id a
*^ Id a
b = forall a. a -> Id a
Id (Scalar (Id a)
a forall a. Num a => a -> a -> a
* a
b)