{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE PolyKinds #-}
module Data.Incremental (
  Incremental(..)
  , Alter(..)
  , Hetero(..)
  , Fresh(..)
) where

import Control.Applicative
import Control.DeepSeq
import qualified Data.Aeson as J
import Data.ByteString (ByteString)
import Data.Fixed
import Data.Functor.Identity
import Data.Semigroup hiding (diff)
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Map.Strict as Map
import Data.Proxy
import qualified Data.Set as Set
import Data.Void
import Data.Int
import Data.Word
import Data.Text (Text)
import Numeric.Natural
import GHC.Generics

class Incremental a where
  -- | the difference type
  type Delta a
  -- | @'maybe' a ('patch' a) ('diff' b a) ≡ b@
  patch :: a -> Delta a -> a
  -- | returns 'Nothing' when there is no update
  diff :: a -> a -> Maybe (Delta a)

instance Incremental () where
  type Delta () = Void
  patch :: () -> Delta () -> ()
patch _ _ = ()
  diff :: () -> () -> Maybe (Delta ())
diff _ _ = Maybe (Delta ())
forall a. Maybe a
Nothing

instance Incremental Void where
  type Delta Void = Void
  patch :: Void -> Delta Void -> Void
patch v :: Void
v _ = Void
v
  diff :: Void -> Void -> Maybe (Delta Void)
diff _ _ = Maybe (Delta Void)
forall a. Maybe a
Nothing

instance Incremental (Proxy a) where
  type Delta (Proxy a) = Void
  patch :: Proxy a -> Delta (Proxy a) -> Proxy a
patch v :: Proxy a
v _ = Proxy a
v
  diff :: Proxy a -> Proxy a -> Maybe (Delta (Proxy a))
diff _ _ = Maybe (Delta (Proxy a))
forall a. Maybe a
Nothing

instance Incremental a => Incremental (Identity a) where
  type Delta (Identity a) = Delta a
  patch :: Identity a -> Delta (Identity a) -> Identity a
patch (Identity a :: a
a) d :: Delta (Identity a)
d = a -> Identity a
forall a. a -> Identity a
Identity (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a Delta a
Delta (Identity a)
d)
  diff :: Identity a -> Identity a -> Maybe (Delta (Identity a))
diff (Identity a :: a
a) (Identity b :: a
b) = a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
b

instance Incremental a => Incremental (Const a b) where
  type Delta (Const a b) = Delta a
  patch :: Const a b -> Delta (Const a b) -> Const a b
patch (Const a :: a
a) d :: Delta (Const a b)
d = a -> Const a b
forall k a (b :: k). a -> Const a b
Const (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a Delta a
Delta (Const a b)
d)
  diff :: Const a b -> Const a b -> Maybe (Delta (Const a b))
diff (Const a :: a
a) (Const b :: a
b) = a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
b

data Alter a d = Insert a
  | Update d
  | Delete a -- ^ last value
  | Delete_
  | Upsert a d
  deriving ((forall x. Alter a d -> Rep (Alter a d) x)
-> (forall x. Rep (Alter a d) x -> Alter a d)
-> Generic (Alter a d)
forall x. Rep (Alter a d) x -> Alter a d
forall x. Alter a d -> Rep (Alter a d) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a d x. Rep (Alter a d) x -> Alter a d
forall a d x. Alter a d -> Rep (Alter a d) x
$cto :: forall a d x. Rep (Alter a d) x -> Alter a d
$cfrom :: forall a d x. Alter a d -> Rep (Alter a d) x
Generic, a -> Alter a b -> Alter a a
(a -> b) -> Alter a a -> Alter a b
(forall a b. (a -> b) -> Alter a a -> Alter a b)
-> (forall a b. a -> Alter a b -> Alter a a) -> Functor (Alter a)
forall a b. a -> Alter a b -> Alter a a
forall a b. (a -> b) -> Alter a a -> Alter a b
forall a a b. a -> Alter a b -> Alter a a
forall a a b. (a -> b) -> Alter a a -> Alter a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Alter a b -> Alter a a
$c<$ :: forall a a b. a -> Alter a b -> Alter a a
fmap :: (a -> b) -> Alter a a -> Alter a b
$cfmap :: forall a a b. (a -> b) -> Alter a a -> Alter a b
Functor)

deriving instance (Show a, Show d) => Show (Alter a d)
instance (NFData a, NFData d) => NFData (Alter a d)

instance (J.FromJSON a, J.FromJSON d) => J.FromJSON (Alter a d)
instance (J.ToJSON a, J.ToJSON d) => J.ToJSON (Alter a d)

instance (Incremental a, d ~ Delta a, Semigroup d) => Semigroup (Alter a d) where
  _ <> :: Alter a d -> Alter a d -> Alter a d
<> Insert a :: a
a = a -> Alter a d
forall a d. a -> Alter a d
Insert a
a
  _ <> Delete a :: a
a = a -> Alter a d
forall a d. a -> Alter a d
Delete a
a
  _ <> Delete_ = Alter a d
forall a d. Alter a d
Delete_
  Insert a :: a
a <> Update d :: d
d = a -> Alter a d
forall a d. a -> Alter a d
Insert (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a d
Delta a
d)
  Insert a :: a
a <> Upsert _ d :: d
d = a -> Alter a d
forall a d. a -> Alter a d
Insert (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a d
Delta a
d)
  Update c :: d
c <> Update d :: d
d = d -> Alter a d
forall a d. d -> Alter a d
Update (d
c d -> d -> d
forall a. Semigroup a => a -> a -> a
<> d
d)
  Update c :: d
c <> Upsert a :: a
a d :: d
d = a -> d -> Alter a d
forall a d. a -> d -> Alter a d
Upsert a
a (d
c d -> d -> d
forall a. Semigroup a => a -> a -> a
<> d
d)
  Delete a :: a
a <> Update _ = a -> Alter a d
forall a d. a -> Alter a d
Delete a
a
  Delete _ <> Upsert a :: a
a _ = a -> Alter a d
forall a d. a -> Alter a d
Insert a
a
  Delete_ <> Update _ = Alter a d
forall a d. Alter a d
Delete_
  Delete_ <> Upsert a :: a
a _ = a -> Alter a d
forall a d. a -> Alter a d
Insert a
a
  Upsert a :: a
a d :: d
d <> Update e :: d
e = a -> d -> Alter a d
forall a d. a -> d -> Alter a d
Upsert (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a d
Delta a
e) (d
d d -> d -> d
forall a. Semigroup a => a -> a -> a
<> d
e)
  Upsert a :: a
a d :: d
d <> Upsert _ e :: d
e = a -> d -> Alter a d
forall a d. a -> d -> Alter a d
Upsert a
a (d
d d -> d -> d
forall a. Semigroup a => a -> a -> a
<> d
e)

instance (Incremental a, Monoid d, d ~ Delta a) => Monoid (Alter a d) where
  mempty :: Alter a d
mempty = d -> Alter a d
forall a d. d -> Alter a d
Update d
forall a. Monoid a => a
mempty
  mappend :: Alter a d -> Alter a d -> Alter a d
mappend = Alter a d -> Alter a d -> Alter a d
forall a. Semigroup a => a -> a -> a
(<>)

instance Incremental a => Incremental (Maybe a) where
  type Delta (Maybe a) = Alter a (Delta a)
  patch :: Maybe a -> Delta (Maybe a) -> Maybe a
patch _ (Insert a) = a -> Maybe a
forall a. a -> Maybe a
Just a
a
  patch (Just a :: a
a) (Update d) = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$! a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a Delta a
d
  patch (Just a :: a
a) (Upsert _ d) = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$! a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a Delta a
d
  patch _ (Upsert a _) = a -> Maybe a
forall a. a -> Maybe a
Just a
a
  patch _ _ = Maybe a
forall a. Maybe a
Nothing
  diff :: Maybe a -> Maybe a -> Maybe (Delta (Maybe a))
diff Nothing (Just a :: a
a) = Alter a (Delta a) -> Maybe (Delta (Maybe a))
forall a. a -> Maybe a
Just (Alter a (Delta a) -> Maybe (Delta (Maybe a)))
-> Alter a (Delta a) -> Maybe (Delta (Maybe a))
forall a b. (a -> b) -> a -> b
$ a -> Alter a (Delta a)
forall a d. a -> Alter a d
Insert a
a
  diff (Just a :: a
a) (Just b :: a
b) = Delta a -> Alter a (Delta a)
forall a d. d -> Alter a d
Update (Delta a -> Alter a (Delta a))
-> Maybe (Delta a) -> Maybe (Alter a (Delta a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
b
  diff (Just a :: a
a) Nothing = Alter a (Delta a) -> Maybe (Alter a (Delta a))
forall a. a -> Maybe a
Just (a -> Alter a (Delta a)
forall a d. a -> Alter a d
Delete a
a)
  diff _ _ = Maybe (Delta (Maybe a))
forall a. Maybe a
Nothing

instance (Incremental a, Incremental b) => Incremental (a, b) where
  type Delta (a, b) = (Maybe (Delta a), Maybe (Delta b))
  patch :: (a, b) -> Delta (a, b) -> (a, b)
patch (a :: a
a, b :: b
b) (d, e) = (a -> (Delta a -> a) -> Maybe (Delta a) -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
a (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a) Maybe (Delta a)
d, b -> (Delta b -> b) -> Maybe (Delta b) -> b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe b
b (b -> Delta b -> b
forall a. Incremental a => a -> Delta a -> a
patch b
b) Maybe (Delta b)
e)
  diff :: (a, b) -> (a, b) -> Maybe (Delta (a, b))
diff (a :: a
a, b :: b
b) (c :: a
c, d :: b
d) = (Maybe (Delta a), Maybe (Delta b))
-> Maybe (Maybe (Delta a), Maybe (Delta b))
forall a. a -> Maybe a
Just (a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
c, b -> b -> Maybe (Delta b)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff b
b b
d)

instance (Incremental a, Incremental b, Incremental c) => Incremental (a, b, c) where
  type Delta (a, b, c) = (Maybe (Delta a), Maybe (Delta b), Maybe (Delta c))
  patch :: (a, b, c) -> Delta (a, b, c) -> (a, b, c)
patch (a :: a
a, b :: b
b, c :: c
c) (d, e, f) = (a -> (Delta a -> a) -> Maybe (Delta a) -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
a (a -> Delta a -> a
forall a. Incremental a => a -> Delta a -> a
patch a
a) Maybe (Delta a)
d, b -> (Delta b -> b) -> Maybe (Delta b) -> b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe b
b (b -> Delta b -> b
forall a. Incremental a => a -> Delta a -> a
patch b
b) Maybe (Delta b)
e, c -> (Delta c -> c) -> Maybe (Delta c) -> c
forall b a. b -> (a -> b) -> Maybe a -> b
maybe c
c (c -> Delta c -> c
forall a. Incremental a => a -> Delta a -> a
patch c
c) Maybe (Delta c)
f)
  diff :: (a, b, c) -> (a, b, c) -> Maybe (Delta (a, b, c))
diff (a :: a
a, b :: b
b, c :: c
c) (d :: a
d, e :: b
e, f :: c
f) = (Maybe (Delta a), Maybe (Delta b), Maybe (Delta c))
-> Maybe (Maybe (Delta a), Maybe (Delta b), Maybe (Delta c))
forall a. a -> Maybe a
Just (a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
d, b -> b -> Maybe (Delta b)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff b
b b
e, c -> c -> Maybe (Delta c)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff c
c c
f)

instance (Incremental a) => Incremental (IntMap.IntMap a) where
  type Delta (IntMap.IntMap a) = IntMap.IntMap (Alter a (Delta a))
  patch :: IntMap a -> Delta (IntMap a) -> IntMap a
patch = (Int -> a -> Alter a (Delta a) -> Maybe a)
-> (IntMap a -> IntMap a)
-> (IntMap (Alter a (Delta a)) -> IntMap a)
-> IntMap a
-> IntMap (Alter a (Delta a))
-> IntMap a
forall a b c.
(Int -> a -> b -> Maybe c)
-> (IntMap a -> IntMap c)
-> (IntMap b -> IntMap c)
-> IntMap a
-> IntMap b
-> IntMap c
IntMap.mergeWithKey (\_ a :: a
a -> Maybe a -> Delta (Maybe a) -> Maybe a
forall a. Incremental a => a -> Delta a -> a
patch (a -> Maybe a
forall a. a -> Maybe a
Just a
a)) IntMap a -> IntMap a
forall a. a -> a
id
    ((IntMap (Alter a (Delta a)) -> IntMap a)
 -> IntMap a -> Delta (IntMap a) -> IntMap a)
-> (IntMap (Alter a (Delta a)) -> IntMap a)
-> IntMap a
-> Delta (IntMap a)
-> IntMap a
forall a b. (a -> b) -> a -> b
$ (Alter a (Delta a) -> Maybe a)
-> IntMap (Alter a (Delta a)) -> IntMap a
forall a b. (a -> Maybe b) -> IntMap a -> IntMap b
IntMap.mapMaybe ((Alter a (Delta a) -> Maybe a)
 -> IntMap (Alter a (Delta a)) -> IntMap a)
-> (Alter a (Delta a) -> Maybe a)
-> IntMap (Alter a (Delta a))
-> IntMap a
forall a b. (a -> b) -> a -> b
$ \case
      Insert a :: a
a -> a -> Maybe a
forall a. a -> Maybe a
Just a
a
      Upsert a :: a
a _ -> a -> Maybe a
forall a. a -> Maybe a
Just a
a
      _ -> Maybe a
forall a. Maybe a
Nothing
  diff :: IntMap a -> IntMap a -> Maybe (Delta (IntMap a))
diff = (IntMap (Alter a (Delta a)) -> Maybe (IntMap (Alter a (Delta a)))
forall a. IntMap a -> Maybe (IntMap a)
check(IntMap (Alter a (Delta a)) -> Maybe (IntMap (Alter a (Delta a))))
-> (IntMap a -> IntMap (Alter a (Delta a)))
-> IntMap a
-> Maybe (IntMap (Alter a (Delta a)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)((IntMap a -> IntMap (Alter a (Delta a)))
 -> IntMap a -> Maybe (IntMap (Alter a (Delta a))))
-> (IntMap a -> IntMap a -> IntMap (Alter a (Delta a)))
-> IntMap a
-> IntMap a
-> Maybe (IntMap (Alter a (Delta a)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> a -> a -> Maybe (Alter a (Delta a)))
-> (IntMap a -> IntMap (Alter a (Delta a)))
-> (IntMap a -> IntMap (Alter a (Delta a)))
-> IntMap a
-> IntMap a
-> IntMap (Alter a (Delta a))
forall a b c.
(Int -> a -> b -> Maybe c)
-> (IntMap a -> IntMap c)
-> (IntMap b -> IntMap c)
-> IntMap a
-> IntMap b
-> IntMap c
IntMap.mergeWithKey (\_ a :: a
a b :: a
b -> Delta a -> Alter a (Delta a)
forall a d. d -> Alter a d
Update (Delta a -> Alter a (Delta a))
-> Maybe (Delta a) -> Maybe (Alter a (Delta a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
b) ((a -> Alter a (Delta a)) -> IntMap a -> IntMap (Alter a (Delta a))
forall a b. (a -> b) -> IntMap a -> IntMap b
IntMap.map a -> Alter a (Delta a)
forall a d. a -> Alter a d
Delete) ((a -> Alter a (Delta a)) -> IntMap a -> IntMap (Alter a (Delta a))
forall a b. (a -> b) -> IntMap a -> IntMap b
IntMap.map a -> Alter a (Delta a)
forall a d. a -> Alter a d
Insert)
    where
      check :: IntMap a -> Maybe (IntMap a)
check m :: IntMap a
m = if IntMap a -> Bool
forall a. IntMap a -> Bool
IntMap.null IntMap a
m then Maybe (IntMap a)
forall a. Maybe a
Nothing else IntMap a -> Maybe (IntMap a)
forall a. a -> Maybe a
Just IntMap a
m

instance (Ord k, Incremental a) => Incremental (Map.Map k a) where
  type Delta (Map.Map k a) = Map.Map k (Alter a (Delta a))
  patch :: Map k a -> Delta (Map k a) -> Map k a
patch = (k -> a -> Alter a (Delta a) -> Maybe a)
-> (Map k a -> Map k a)
-> (Map k (Alter a (Delta a)) -> Map k a)
-> Map k a
-> Map k (Alter a (Delta a))
-> Map k a
forall k a b c.
Ord k =>
(k -> a -> b -> Maybe c)
-> (Map k a -> Map k c)
-> (Map k b -> Map k c)
-> Map k a
-> Map k b
-> Map k c
Map.mergeWithKey (\_ a :: a
a -> Maybe a -> Delta (Maybe a) -> Maybe a
forall a. Incremental a => a -> Delta a -> a
patch (a -> Maybe a
forall a. a -> Maybe a
Just a
a)) Map k a -> Map k a
forall a. a -> a
id
    ((Map k (Alter a (Delta a)) -> Map k a)
 -> Map k a -> Delta (Map k a) -> Map k a)
-> (Map k (Alter a (Delta a)) -> Map k a)
-> Map k a
-> Delta (Map k a)
-> Map k a
forall a b. (a -> b) -> a -> b
$ (Alter a (Delta a) -> Maybe a)
-> Map k (Alter a (Delta a)) -> Map k a
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe ((Alter a (Delta a) -> Maybe a)
 -> Map k (Alter a (Delta a)) -> Map k a)
-> (Alter a (Delta a) -> Maybe a)
-> Map k (Alter a (Delta a))
-> Map k a
forall a b. (a -> b) -> a -> b
$ \case
      Insert a :: a
a -> a -> Maybe a
forall a. a -> Maybe a
Just a
a
      Upsert a :: a
a _ -> a -> Maybe a
forall a. a -> Maybe a
Just a
a
      _ -> Maybe a
forall a. Maybe a
Nothing
  diff :: Map k a -> Map k a -> Maybe (Delta (Map k a))
diff = (Map k (Alter a (Delta a)) -> Maybe (Map k (Alter a (Delta a)))
forall k a. Map k a -> Maybe (Map k a)
check(Map k (Alter a (Delta a)) -> Maybe (Map k (Alter a (Delta a))))
-> (Map k a -> Map k (Alter a (Delta a)))
-> Map k a
-> Maybe (Map k (Alter a (Delta a)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)((Map k a -> Map k (Alter a (Delta a)))
 -> Map k a -> Maybe (Map k (Alter a (Delta a))))
-> (Map k a -> Map k a -> Map k (Alter a (Delta a)))
-> Map k a
-> Map k a
-> Maybe (Map k (Alter a (Delta a)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> a -> a -> Maybe (Alter a (Delta a)))
-> (Map k a -> Map k (Alter a (Delta a)))
-> (Map k a -> Map k (Alter a (Delta a)))
-> Map k a
-> Map k a
-> Map k (Alter a (Delta a))
forall k a b c.
Ord k =>
(k -> a -> b -> Maybe c)
-> (Map k a -> Map k c)
-> (Map k b -> Map k c)
-> Map k a
-> Map k b
-> Map k c
Map.mergeWithKey (\_ a :: a
a b :: a
b -> Delta a -> Alter a (Delta a)
forall a d. d -> Alter a d
Update (Delta a -> Alter a (Delta a))
-> Maybe (Delta a) -> Maybe (Alter a (Delta a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe (Delta a)
forall a. Incremental a => a -> a -> Maybe (Delta a)
diff a
a a
b) ((a -> Alter a (Delta a)) -> Map k a -> Map k (Alter a (Delta a))
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map a -> Alter a (Delta a)
forall a d. a -> Alter a d
Delete) ((a -> Alter a (Delta a)) -> Map k a -> Map k (Alter a (Delta a))
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map a -> Alter a (Delta a)
forall a d. a -> Alter a d
Insert)
    where
      check :: Map k a -> Maybe (Map k a)
check m :: Map k a
m = if Map k a -> Bool
forall k a. Map k a -> Bool
Map.null Map k a
m then Maybe (Map k a)
forall a. Maybe a
Nothing else Map k a -> Maybe (Map k a)
forall a. a -> Maybe a
Just Map k a
m

instance Ord a => Incremental (Set.Set a) where
  -- | (insertion, deletion)
  type Delta (Set.Set a) = (Set.Set a, Set.Set a)
  patch :: Set a -> Delta (Set a) -> Set a
patch s :: Set a
s (ins, del) = Set a
s Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Set a
del Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set a
ins
  diff :: Set a -> Set a -> Maybe (Delta (Set a))
diff a :: Set a
a b :: Set a
b = (Set a, Set a) -> Maybe (Delta (Set a))
forall a a. (Set a, Set a) -> Maybe (Set a, Set a)
check ((Set a, Set a) -> Maybe (Delta (Set a)))
-> (Set a, Set a) -> Maybe (Delta (Set a))
forall a b. (a -> b) -> a -> b
$ [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
forall a. Ord a => [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
go (Set a -> [a]
forall a. Set a -> [a]
Set.toAscList Set a
a) (Set a -> [a]
forall a. Set a -> [a]
Set.toAscList Set a
b) Set a
forall a. Set a
Set.empty Set a
forall a. Set a
Set.empty where
    go :: [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
go xs' :: [a]
xs'@(x :: a
x:xs :: [a]
xs) ys' :: [a]
ys'@(y :: a
y:ys :: [a]
ys) s :: Set a
s t :: Set a
t = case a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y of
      LT -> [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
go [a]
xs [a]
ys' Set a
s (a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert a
x Set a
t)
      EQ -> [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
go [a]
xs [a]
ys Set a
s Set a
t
      GT -> [a] -> [a] -> Set a -> Set a -> (Set a, Set a)
go [a]
xs' [a]
ys (a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert a
y Set a
s) Set a
t
    go xs :: [a]
xs ys :: [a]
ys s :: Set a
s t :: Set a
t = ((a -> Set a -> Set a) -> Set a -> [a] -> Set a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert Set a
s [a]
ys, (a -> Set a -> Set a) -> Set a -> [a] -> Set a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert Set a
t [a]
xs)
    check :: (Set a, Set a) -> Maybe (Set a, Set a)
check r :: (Set a, Set a)
r@(s :: Set a
s, t :: Set a
t)
      | Set a -> Bool
forall a. Set a -> Bool
Set.null Set a
s, Set a -> Bool
forall a. Set a -> Bool
Set.null Set a
t = Maybe (Set a, Set a)
forall a. Maybe a
Nothing
      | Bool
otherwise = (Set a, Set a) -> Maybe (Set a, Set a)
forall a. a -> Maybe a
Just (Set a, Set a)
r

instance Num a => Incremental (Sum a) where
  type Delta (Sum a) = Sum a
  patch :: Sum a -> Delta (Sum a) -> Sum a
patch = Sum a -> Delta (Sum a) -> Sum a
forall a. Semigroup a => a -> a -> a
(<>)
  diff :: Sum a -> Sum a -> Maybe (Delta (Sum a))
diff (Sum a :: a
a) (Sum b :: a
b) = Sum a -> Maybe (Delta (Sum a))
forall a. a -> Maybe a
Just (Sum a -> Maybe (Delta (Sum a))) -> Sum a -> Maybe (Delta (Sum a))
forall a b. (a -> b) -> a -> b
$ a -> Sum a
forall a. a -> Sum a
Sum (a
b a -> a -> a
forall a. Num a => a -> a -> a
- a
a)

instance Eq a => Incremental [a] where
  type Delta [a] = [a]
  patch :: [a] -> Delta [a] -> [a]
patch _ xs :: Delta [a]
xs = [a]
Delta [a]
xs
  diff :: [a] -> [a] -> Maybe (Delta [a])
diff a :: [a]
a b :: [a]
b
    | [a]
a [a] -> [a] -> Bool
forall a. Eq a => a -> a -> Bool
== [a]
b = Maybe (Delta [a])
forall a. Maybe a
Nothing
    | Bool
otherwise = [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
b

newtype Hetero a = Hetero { Hetero a -> a
getHetero :: a }
  deriving (Hetero a
Hetero a -> Hetero a -> Bounded (Hetero a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Hetero a
maxBound :: Hetero a
$cmaxBound :: forall a. Bounded a => Hetero a
minBound :: Hetero a
$cminBound :: forall a. Bounded a => Hetero a
Bounded, Int -> Hetero a
Hetero a -> Int
Hetero a -> [Hetero a]
Hetero a -> Hetero a
Hetero a -> Hetero a -> [Hetero a]
Hetero a -> Hetero a -> Hetero a -> [Hetero a]
(Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Int -> Hetero a)
-> (Hetero a -> Int)
-> (Hetero a -> [Hetero a])
-> (Hetero a -> Hetero a -> [Hetero a])
-> (Hetero a -> Hetero a -> [Hetero a])
-> (Hetero a -> Hetero a -> Hetero a -> [Hetero a])
-> Enum (Hetero a)
forall a. Enum a => Int -> Hetero a
forall a. Enum a => Hetero a -> Int
forall a. Enum a => Hetero a -> [Hetero a]
forall a. Enum a => Hetero a -> Hetero a
forall a. Enum a => Hetero a -> Hetero a -> [Hetero a]
forall a. Enum a => Hetero a -> Hetero a -> Hetero a -> [Hetero 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 :: Hetero a -> Hetero a -> Hetero a -> [Hetero a]
$cenumFromThenTo :: forall a. Enum a => Hetero a -> Hetero a -> Hetero a -> [Hetero a]
enumFromTo :: Hetero a -> Hetero a -> [Hetero a]
$cenumFromTo :: forall a. Enum a => Hetero a -> Hetero a -> [Hetero a]
enumFromThen :: Hetero a -> Hetero a -> [Hetero a]
$cenumFromThen :: forall a. Enum a => Hetero a -> Hetero a -> [Hetero a]
enumFrom :: Hetero a -> [Hetero a]
$cenumFrom :: forall a. Enum a => Hetero a -> [Hetero a]
fromEnum :: Hetero a -> Int
$cfromEnum :: forall a. Enum a => Hetero a -> Int
toEnum :: Int -> Hetero a
$ctoEnum :: forall a. Enum a => Int -> Hetero a
pred :: Hetero a -> Hetero a
$cpred :: forall a. Enum a => Hetero a -> Hetero a
succ :: Hetero a -> Hetero a
$csucc :: forall a. Enum a => Hetero a -> Hetero a
Enum, Hetero a -> Hetero a -> Bool
(Hetero a -> Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Bool) -> Eq (Hetero a)
forall a. Eq a => Hetero a -> Hetero a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hetero a -> Hetero a -> Bool
$c/= :: forall a. Eq a => Hetero a -> Hetero a -> Bool
== :: Hetero a -> Hetero a -> Bool
$c== :: forall a. Eq a => Hetero a -> Hetero a -> Bool
Eq, Fractional (Hetero a)
Hetero a
Fractional (Hetero a) =>
Hetero a
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> Floating (Hetero a)
Hetero a -> Hetero a
Hetero a -> Hetero a -> Hetero a
forall a. Floating a => Fractional (Hetero a)
forall a. Floating a => Hetero a
forall a. Floating a => Hetero a -> Hetero a
forall a. Floating a => Hetero a -> Hetero a -> Hetero 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 :: Hetero a -> Hetero a
$clog1mexp :: forall a. Floating a => Hetero a -> Hetero a
log1pexp :: Hetero a -> Hetero a
$clog1pexp :: forall a. Floating a => Hetero a -> Hetero a
expm1 :: Hetero a -> Hetero a
$cexpm1 :: forall a. Floating a => Hetero a -> Hetero a
log1p :: Hetero a -> Hetero a
$clog1p :: forall a. Floating a => Hetero a -> Hetero a
atanh :: Hetero a -> Hetero a
$catanh :: forall a. Floating a => Hetero a -> Hetero a
acosh :: Hetero a -> Hetero a
$cacosh :: forall a. Floating a => Hetero a -> Hetero a
asinh :: Hetero a -> Hetero a
$casinh :: forall a. Floating a => Hetero a -> Hetero a
tanh :: Hetero a -> Hetero a
$ctanh :: forall a. Floating a => Hetero a -> Hetero a
cosh :: Hetero a -> Hetero a
$ccosh :: forall a. Floating a => Hetero a -> Hetero a
sinh :: Hetero a -> Hetero a
$csinh :: forall a. Floating a => Hetero a -> Hetero a
atan :: Hetero a -> Hetero a
$catan :: forall a. Floating a => Hetero a -> Hetero a
acos :: Hetero a -> Hetero a
$cacos :: forall a. Floating a => Hetero a -> Hetero a
asin :: Hetero a -> Hetero a
$casin :: forall a. Floating a => Hetero a -> Hetero a
tan :: Hetero a -> Hetero a
$ctan :: forall a. Floating a => Hetero a -> Hetero a
cos :: Hetero a -> Hetero a
$ccos :: forall a. Floating a => Hetero a -> Hetero a
sin :: Hetero a -> Hetero a
$csin :: forall a. Floating a => Hetero a -> Hetero a
logBase :: Hetero a -> Hetero a -> Hetero a
$clogBase :: forall a. Floating a => Hetero a -> Hetero a -> Hetero a
** :: Hetero a -> Hetero a -> Hetero a
$c** :: forall a. Floating a => Hetero a -> Hetero a -> Hetero a
sqrt :: Hetero a -> Hetero a
$csqrt :: forall a. Floating a => Hetero a -> Hetero a
log :: Hetero a -> Hetero a
$clog :: forall a. Floating a => Hetero a -> Hetero a
exp :: Hetero a -> Hetero a
$cexp :: forall a. Floating a => Hetero a -> Hetero a
pi :: Hetero a
$cpi :: forall a. Floating a => Hetero a
$cp1Floating :: forall a. Floating a => Fractional (Hetero a)
Floating, Num (Hetero a)
Num (Hetero a) =>
(Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Rational -> Hetero a)
-> Fractional (Hetero a)
Rational -> Hetero a
Hetero a -> Hetero a
Hetero a -> Hetero a -> Hetero a
forall a. Fractional a => Num (Hetero a)
forall a. Fractional a => Rational -> Hetero a
forall a. Fractional a => Hetero a -> Hetero a
forall a. Fractional a => Hetero a -> Hetero a -> Hetero a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Hetero a
$cfromRational :: forall a. Fractional a => Rational -> Hetero a
recip :: Hetero a -> Hetero a
$crecip :: forall a. Fractional a => Hetero a -> Hetero a
/ :: Hetero a -> Hetero a -> Hetero a
$c/ :: forall a. Fractional a => Hetero a -> Hetero a -> Hetero a
$cp1Fractional :: forall a. Fractional a => Num (Hetero a)
Fractional, Enum (Hetero a)
Real (Hetero a)
(Real (Hetero a), Enum (Hetero a)) =>
(Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> (Hetero a, Hetero a))
-> (Hetero a -> Hetero a -> (Hetero a, Hetero a))
-> (Hetero a -> Integer)
-> Integral (Hetero a)
Hetero a -> Integer
Hetero a -> Hetero a -> (Hetero a, Hetero a)
Hetero a -> Hetero a -> Hetero a
forall a. Integral a => Enum (Hetero a)
forall a. Integral a => Real (Hetero a)
forall a. Integral a => Hetero a -> Integer
forall a.
Integral a =>
Hetero a -> Hetero a -> (Hetero a, Hetero a)
forall a. Integral a => Hetero a -> Hetero a -> Hetero a
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: Hetero a -> Integer
$ctoInteger :: forall a. Integral a => Hetero a -> Integer
divMod :: Hetero a -> Hetero a -> (Hetero a, Hetero a)
$cdivMod :: forall a.
Integral a =>
Hetero a -> Hetero a -> (Hetero a, Hetero a)
quotRem :: Hetero a -> Hetero a -> (Hetero a, Hetero a)
$cquotRem :: forall a.
Integral a =>
Hetero a -> Hetero a -> (Hetero a, Hetero a)
mod :: Hetero a -> Hetero a -> Hetero a
$cmod :: forall a. Integral a => Hetero a -> Hetero a -> Hetero a
div :: Hetero a -> Hetero a -> Hetero a
$cdiv :: forall a. Integral a => Hetero a -> Hetero a -> Hetero a
rem :: Hetero a -> Hetero a -> Hetero a
$crem :: forall a. Integral a => Hetero a -> Hetero a -> Hetero a
quot :: Hetero a -> Hetero a -> Hetero a
$cquot :: forall a. Integral a => Hetero a -> Hetero a -> Hetero a
$cp2Integral :: forall a. Integral a => Enum (Hetero a)
$cp1Integral :: forall a. Integral a => Real (Hetero a)
Integral, b -> Hetero a -> Hetero a
NonEmpty (Hetero a) -> Hetero a
Hetero a -> Hetero a -> Hetero a
(Hetero a -> Hetero a -> Hetero a)
-> (NonEmpty (Hetero a) -> Hetero a)
-> (forall b. Integral b => b -> Hetero a -> Hetero a)
-> Semigroup (Hetero a)
forall b. Integral b => b -> Hetero a -> Hetero a
forall a. Semigroup a => NonEmpty (Hetero a) -> Hetero a
forall a. Semigroup a => Hetero a -> Hetero a -> Hetero a
forall a b. (Semigroup a, Integral b) => b -> Hetero a -> Hetero a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Hetero a -> Hetero a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Hetero a -> Hetero a
sconcat :: NonEmpty (Hetero a) -> Hetero a
$csconcat :: forall a. Semigroup a => NonEmpty (Hetero a) -> Hetero a
<> :: Hetero a -> Hetero a -> Hetero a
$c<> :: forall a. Semigroup a => Hetero a -> Hetero a -> Hetero a
Semigroup
      , Semigroup (Hetero a)
Hetero a
Semigroup (Hetero a) =>
Hetero a
-> (Hetero a -> Hetero a -> Hetero a)
-> ([Hetero a] -> Hetero a)
-> Monoid (Hetero a)
[Hetero a] -> Hetero a
Hetero a -> Hetero a -> Hetero a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Hetero a)
forall a. Monoid a => Hetero a
forall a. Monoid a => [Hetero a] -> Hetero a
forall a. Monoid a => Hetero a -> Hetero a -> Hetero a
mconcat :: [Hetero a] -> Hetero a
$cmconcat :: forall a. Monoid a => [Hetero a] -> Hetero a
mappend :: Hetero a -> Hetero a -> Hetero a
$cmappend :: forall a. Monoid a => Hetero a -> Hetero a -> Hetero a
mempty :: Hetero a
$cmempty :: forall a. Monoid a => Hetero a
$cp1Monoid :: forall a. Monoid a => Semigroup (Hetero a)
Monoid, Integer -> Hetero a
Hetero a -> Hetero a
Hetero a -> Hetero a -> Hetero a
(Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Hetero a -> Hetero a)
-> (Integer -> Hetero a)
-> Num (Hetero a)
forall a. Num a => Integer -> Hetero a
forall a. Num a => Hetero a -> Hetero a
forall a. Num a => Hetero a -> Hetero a -> Hetero a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Hetero a
$cfromInteger :: forall a. Num a => Integer -> Hetero a
signum :: Hetero a -> Hetero a
$csignum :: forall a. Num a => Hetero a -> Hetero a
abs :: Hetero a -> Hetero a
$cabs :: forall a. Num a => Hetero a -> Hetero a
negate :: Hetero a -> Hetero a
$cnegate :: forall a. Num a => Hetero a -> Hetero a
* :: Hetero a -> Hetero a -> Hetero a
$c* :: forall a. Num a => Hetero a -> Hetero a -> Hetero a
- :: Hetero a -> Hetero a -> Hetero a
$c- :: forall a. Num a => Hetero a -> Hetero a -> Hetero a
+ :: Hetero a -> Hetero a -> Hetero a
$c+ :: forall a. Num a => Hetero a -> Hetero a -> Hetero a
Num, Eq (Hetero a)
Eq (Hetero a) =>
(Hetero a -> Hetero a -> Ordering)
-> (Hetero a -> Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Hetero a)
-> (Hetero a -> Hetero a -> Hetero a)
-> Ord (Hetero a)
Hetero a -> Hetero a -> Bool
Hetero a -> Hetero a -> Ordering
Hetero a -> Hetero a -> Hetero 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 (Hetero a)
forall a. Ord a => Hetero a -> Hetero a -> Bool
forall a. Ord a => Hetero a -> Hetero a -> Ordering
forall a. Ord a => Hetero a -> Hetero a -> Hetero a
min :: Hetero a -> Hetero a -> Hetero a
$cmin :: forall a. Ord a => Hetero a -> Hetero a -> Hetero a
max :: Hetero a -> Hetero a -> Hetero a
$cmax :: forall a. Ord a => Hetero a -> Hetero a -> Hetero a
>= :: Hetero a -> Hetero a -> Bool
$c>= :: forall a. Ord a => Hetero a -> Hetero a -> Bool
> :: Hetero a -> Hetero a -> Bool
$c> :: forall a. Ord a => Hetero a -> Hetero a -> Bool
<= :: Hetero a -> Hetero a -> Bool
$c<= :: forall a. Ord a => Hetero a -> Hetero a -> Bool
< :: Hetero a -> Hetero a -> Bool
$c< :: forall a. Ord a => Hetero a -> Hetero a -> Bool
compare :: Hetero a -> Hetero a -> Ordering
$ccompare :: forall a. Ord a => Hetero a -> Hetero a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Hetero a)
Ord, Num (Hetero a)
Ord (Hetero a)
(Num (Hetero a), Ord (Hetero a)) =>
(Hetero a -> Rational) -> Real (Hetero a)
Hetero a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (Hetero a)
forall a. Real a => Ord (Hetero a)
forall a. Real a => Hetero a -> Rational
toRational :: Hetero a -> Rational
$ctoRational :: forall a. Real a => Hetero a -> Rational
$cp2Real :: forall a. Real a => Ord (Hetero a)
$cp1Real :: forall a. Real a => Num (Hetero a)
Real, Fractional (Hetero a)
Real (Hetero a)
(Real (Hetero a), Fractional (Hetero a)) =>
(forall b. Integral b => Hetero a -> (b, Hetero a))
-> (forall b. Integral b => Hetero a -> b)
-> (forall b. Integral b => Hetero a -> b)
-> (forall b. Integral b => Hetero a -> b)
-> (forall b. Integral b => Hetero a -> b)
-> RealFrac (Hetero a)
Hetero a -> b
Hetero a -> b
Hetero a -> b
Hetero a -> b
Hetero a -> (b, Hetero a)
forall b. Integral b => Hetero a -> b
forall b. Integral b => Hetero a -> (b, Hetero 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 (Hetero a)
forall a. RealFrac a => Real (Hetero a)
forall a b. (RealFrac a, Integral b) => Hetero a -> b
forall a b. (RealFrac a, Integral b) => Hetero a -> (b, Hetero a)
floor :: Hetero a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Hetero a -> b
ceiling :: Hetero a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Hetero a -> b
round :: Hetero a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Hetero a -> b
truncate :: Hetero a -> b
$ctruncate :: forall a b. (RealFrac a, Integral b) => Hetero a -> b
properFraction :: Hetero a -> (b, Hetero a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => Hetero a -> (b, Hetero a)
$cp2RealFrac :: forall a. RealFrac a => Fractional (Hetero a)
$cp1RealFrac :: forall a. RealFrac a => Real (Hetero a)
RealFrac, Floating (Hetero a)
RealFrac (Hetero a)
(RealFrac (Hetero a), Floating (Hetero a)) =>
(Hetero a -> Integer)
-> (Hetero a -> Int)
-> (Hetero a -> (Int, Int))
-> (Hetero a -> (Integer, Int))
-> (Integer -> Int -> Hetero a)
-> (Hetero a -> Int)
-> (Hetero a -> Hetero a)
-> (Int -> Hetero a -> Hetero a)
-> (Hetero a -> Bool)
-> (Hetero a -> Bool)
-> (Hetero a -> Bool)
-> (Hetero a -> Bool)
-> (Hetero a -> Bool)
-> (Hetero a -> Hetero a -> Hetero a)
-> RealFloat (Hetero a)
Int -> Hetero a -> Hetero a
Integer -> Int -> Hetero a
Hetero a -> Bool
Hetero a -> Int
Hetero a -> Integer
Hetero a -> (Int, Int)
Hetero a -> (Integer, Int)
Hetero a -> Hetero a
Hetero a -> Hetero a -> Hetero a
forall a. RealFloat a => Floating (Hetero a)
forall a. RealFloat a => RealFrac (Hetero a)
forall a. RealFloat a => Int -> Hetero a -> Hetero a
forall a. RealFloat a => Integer -> Int -> Hetero a
forall a. RealFloat a => Hetero a -> Bool
forall a. RealFloat a => Hetero a -> Int
forall a. RealFloat a => Hetero a -> Integer
forall a. RealFloat a => Hetero a -> (Int, Int)
forall a. RealFloat a => Hetero a -> (Integer, Int)
forall a. RealFloat a => Hetero a -> Hetero a
forall a. RealFloat a => Hetero a -> Hetero a -> Hetero 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 :: Hetero a -> Hetero a -> Hetero a
$catan2 :: forall a. RealFloat a => Hetero a -> Hetero a -> Hetero a
isIEEE :: Hetero a -> Bool
$cisIEEE :: forall a. RealFloat a => Hetero a -> Bool
isNegativeZero :: Hetero a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Hetero a -> Bool
isDenormalized :: Hetero a -> Bool
$cisDenormalized :: forall a. RealFloat a => Hetero a -> Bool
isInfinite :: Hetero a -> Bool
$cisInfinite :: forall a. RealFloat a => Hetero a -> Bool
isNaN :: Hetero a -> Bool
$cisNaN :: forall a. RealFloat a => Hetero a -> Bool
scaleFloat :: Int -> Hetero a -> Hetero a
$cscaleFloat :: forall a. RealFloat a => Int -> Hetero a -> Hetero a
significand :: Hetero a -> Hetero a
$csignificand :: forall a. RealFloat a => Hetero a -> Hetero a
exponent :: Hetero a -> Int
$cexponent :: forall a. RealFloat a => Hetero a -> Int
encodeFloat :: Integer -> Int -> Hetero a
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Hetero a
decodeFloat :: Hetero a -> (Integer, Int)
$cdecodeFloat :: forall a. RealFloat a => Hetero a -> (Integer, Int)
floatRange :: Hetero a -> (Int, Int)
$cfloatRange :: forall a. RealFloat a => Hetero a -> (Int, Int)
floatDigits :: Hetero a -> Int
$cfloatDigits :: forall a. RealFloat a => Hetero a -> Int
floatRadix :: Hetero a -> Integer
$cfloatRadix :: forall a. RealFloat a => Hetero a -> Integer
$cp2RealFloat :: forall a. RealFloat a => Floating (Hetero a)
$cp1RealFloat :: forall a. RealFloat a => RealFrac (Hetero a)
RealFloat, (forall x. Hetero a -> Rep (Hetero a) x)
-> (forall x. Rep (Hetero a) x -> Hetero a) -> Generic (Hetero a)
forall x. Rep (Hetero a) x -> Hetero a
forall x. Hetero a -> Rep (Hetero a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Hetero a) x -> Hetero a
forall a x. Hetero a -> Rep (Hetero a) x
$cto :: forall a x. Rep (Hetero a) x -> Hetero a
$cfrom :: forall a x. Hetero a -> Rep (Hetero a) x
Generic, Hetero a -> ()
(Hetero a -> ()) -> NFData (Hetero a)
forall a. NFData a => Hetero a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Hetero a -> ()
$crnf :: forall a. NFData a => Hetero a -> ()
NFData)

-- | 'diff' checks equality
instance Eq a => Incremental (Hetero a) where
  type Delta (Hetero a) = a
  patch :: Hetero a -> Delta (Hetero a) -> Hetero a
patch _ = Delta (Hetero a) -> Hetero a
forall a. a -> Hetero a
Hetero
  diff :: Hetero a -> Hetero a -> Maybe (Delta (Hetero a))
diff (Hetero a :: a
a) (Hetero b :: a
b)
    | a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
b = a -> Maybe a
forall a. a -> Maybe a
Just a
b
    | Bool
otherwise = Maybe (Delta (Hetero a))
forall a. Maybe a
Nothing

newtype Fresh a = Fresh { Fresh a -> a
getFresh :: a }
  deriving (Fresh a
Fresh a -> Fresh a -> Bounded (Fresh a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Fresh a
maxBound :: Fresh a
$cmaxBound :: forall a. Bounded a => Fresh a
minBound :: Fresh a
$cminBound :: forall a. Bounded a => Fresh a
Bounded, Int -> Fresh a
Fresh a -> Int
Fresh a -> [Fresh a]
Fresh a -> Fresh a
Fresh a -> Fresh a -> [Fresh a]
Fresh a -> Fresh a -> Fresh a -> [Fresh a]
(Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Int -> Fresh a)
-> (Fresh a -> Int)
-> (Fresh a -> [Fresh a])
-> (Fresh a -> Fresh a -> [Fresh a])
-> (Fresh a -> Fresh a -> [Fresh a])
-> (Fresh a -> Fresh a -> Fresh a -> [Fresh a])
-> Enum (Fresh a)
forall a. Enum a => Int -> Fresh a
forall a. Enum a => Fresh a -> Int
forall a. Enum a => Fresh a -> [Fresh a]
forall a. Enum a => Fresh a -> Fresh a
forall a. Enum a => Fresh a -> Fresh a -> [Fresh a]
forall a. Enum a => Fresh a -> Fresh a -> Fresh a -> [Fresh 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 :: Fresh a -> Fresh a -> Fresh a -> [Fresh a]
$cenumFromThenTo :: forall a. Enum a => Fresh a -> Fresh a -> Fresh a -> [Fresh a]
enumFromTo :: Fresh a -> Fresh a -> [Fresh a]
$cenumFromTo :: forall a. Enum a => Fresh a -> Fresh a -> [Fresh a]
enumFromThen :: Fresh a -> Fresh a -> [Fresh a]
$cenumFromThen :: forall a. Enum a => Fresh a -> Fresh a -> [Fresh a]
enumFrom :: Fresh a -> [Fresh a]
$cenumFrom :: forall a. Enum a => Fresh a -> [Fresh a]
fromEnum :: Fresh a -> Int
$cfromEnum :: forall a. Enum a => Fresh a -> Int
toEnum :: Int -> Fresh a
$ctoEnum :: forall a. Enum a => Int -> Fresh a
pred :: Fresh a -> Fresh a
$cpred :: forall a. Enum a => Fresh a -> Fresh a
succ :: Fresh a -> Fresh a
$csucc :: forall a. Enum a => Fresh a -> Fresh a
Enum, Fresh a -> Fresh a -> Bool
(Fresh a -> Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Bool) -> Eq (Fresh a)
forall a. Eq a => Fresh a -> Fresh a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fresh a -> Fresh a -> Bool
$c/= :: forall a. Eq a => Fresh a -> Fresh a -> Bool
== :: Fresh a -> Fresh a -> Bool
$c== :: forall a. Eq a => Fresh a -> Fresh a -> Bool
Eq, Fractional (Fresh a)
Fresh a
Fractional (Fresh a) =>
Fresh a
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> Floating (Fresh a)
Fresh a -> Fresh a
Fresh a -> Fresh a -> Fresh a
forall a. Floating a => Fractional (Fresh a)
forall a. Floating a => Fresh a
forall a. Floating a => Fresh a -> Fresh a
forall a. Floating a => Fresh a -> Fresh a -> Fresh 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 :: Fresh a -> Fresh a
$clog1mexp :: forall a. Floating a => Fresh a -> Fresh a
log1pexp :: Fresh a -> Fresh a
$clog1pexp :: forall a. Floating a => Fresh a -> Fresh a
expm1 :: Fresh a -> Fresh a
$cexpm1 :: forall a. Floating a => Fresh a -> Fresh a
log1p :: Fresh a -> Fresh a
$clog1p :: forall a. Floating a => Fresh a -> Fresh a
atanh :: Fresh a -> Fresh a
$catanh :: forall a. Floating a => Fresh a -> Fresh a
acosh :: Fresh a -> Fresh a
$cacosh :: forall a. Floating a => Fresh a -> Fresh a
asinh :: Fresh a -> Fresh a
$casinh :: forall a. Floating a => Fresh a -> Fresh a
tanh :: Fresh a -> Fresh a
$ctanh :: forall a. Floating a => Fresh a -> Fresh a
cosh :: Fresh a -> Fresh a
$ccosh :: forall a. Floating a => Fresh a -> Fresh a
sinh :: Fresh a -> Fresh a
$csinh :: forall a. Floating a => Fresh a -> Fresh a
atan :: Fresh a -> Fresh a
$catan :: forall a. Floating a => Fresh a -> Fresh a
acos :: Fresh a -> Fresh a
$cacos :: forall a. Floating a => Fresh a -> Fresh a
asin :: Fresh a -> Fresh a
$casin :: forall a. Floating a => Fresh a -> Fresh a
tan :: Fresh a -> Fresh a
$ctan :: forall a. Floating a => Fresh a -> Fresh a
cos :: Fresh a -> Fresh a
$ccos :: forall a. Floating a => Fresh a -> Fresh a
sin :: Fresh a -> Fresh a
$csin :: forall a. Floating a => Fresh a -> Fresh a
logBase :: Fresh a -> Fresh a -> Fresh a
$clogBase :: forall a. Floating a => Fresh a -> Fresh a -> Fresh a
** :: Fresh a -> Fresh a -> Fresh a
$c** :: forall a. Floating a => Fresh a -> Fresh a -> Fresh a
sqrt :: Fresh a -> Fresh a
$csqrt :: forall a. Floating a => Fresh a -> Fresh a
log :: Fresh a -> Fresh a
$clog :: forall a. Floating a => Fresh a -> Fresh a
exp :: Fresh a -> Fresh a
$cexp :: forall a. Floating a => Fresh a -> Fresh a
pi :: Fresh a
$cpi :: forall a. Floating a => Fresh a
$cp1Floating :: forall a. Floating a => Fractional (Fresh a)
Floating, Num (Fresh a)
Num (Fresh a) =>
(Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Rational -> Fresh a)
-> Fractional (Fresh a)
Rational -> Fresh a
Fresh a -> Fresh a
Fresh a -> Fresh a -> Fresh a
forall a. Fractional a => Num (Fresh a)
forall a. Fractional a => Rational -> Fresh a
forall a. Fractional a => Fresh a -> Fresh a
forall a. Fractional a => Fresh a -> Fresh a -> Fresh a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Fresh a
$cfromRational :: forall a. Fractional a => Rational -> Fresh a
recip :: Fresh a -> Fresh a
$crecip :: forall a. Fractional a => Fresh a -> Fresh a
/ :: Fresh a -> Fresh a -> Fresh a
$c/ :: forall a. Fractional a => Fresh a -> Fresh a -> Fresh a
$cp1Fractional :: forall a. Fractional a => Num (Fresh a)
Fractional, Enum (Fresh a)
Real (Fresh a)
(Real (Fresh a), Enum (Fresh a)) =>
(Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> (Fresh a, Fresh a))
-> (Fresh a -> Fresh a -> (Fresh a, Fresh a))
-> (Fresh a -> Integer)
-> Integral (Fresh a)
Fresh a -> Integer
Fresh a -> Fresh a -> (Fresh a, Fresh a)
Fresh a -> Fresh a -> Fresh a
forall a. Integral a => Enum (Fresh a)
forall a. Integral a => Real (Fresh a)
forall a. Integral a => Fresh a -> Integer
forall a. Integral a => Fresh a -> Fresh a -> (Fresh a, Fresh a)
forall a. Integral a => Fresh a -> Fresh a -> Fresh a
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: Fresh a -> Integer
$ctoInteger :: forall a. Integral a => Fresh a -> Integer
divMod :: Fresh a -> Fresh a -> (Fresh a, Fresh a)
$cdivMod :: forall a. Integral a => Fresh a -> Fresh a -> (Fresh a, Fresh a)
quotRem :: Fresh a -> Fresh a -> (Fresh a, Fresh a)
$cquotRem :: forall a. Integral a => Fresh a -> Fresh a -> (Fresh a, Fresh a)
mod :: Fresh a -> Fresh a -> Fresh a
$cmod :: forall a. Integral a => Fresh a -> Fresh a -> Fresh a
div :: Fresh a -> Fresh a -> Fresh a
$cdiv :: forall a. Integral a => Fresh a -> Fresh a -> Fresh a
rem :: Fresh a -> Fresh a -> Fresh a
$crem :: forall a. Integral a => Fresh a -> Fresh a -> Fresh a
quot :: Fresh a -> Fresh a -> Fresh a
$cquot :: forall a. Integral a => Fresh a -> Fresh a -> Fresh a
$cp2Integral :: forall a. Integral a => Enum (Fresh a)
$cp1Integral :: forall a. Integral a => Real (Fresh a)
Integral, b -> Fresh a -> Fresh a
NonEmpty (Fresh a) -> Fresh a
Fresh a -> Fresh a -> Fresh a
(Fresh a -> Fresh a -> Fresh a)
-> (NonEmpty (Fresh a) -> Fresh a)
-> (forall b. Integral b => b -> Fresh a -> Fresh a)
-> Semigroup (Fresh a)
forall b. Integral b => b -> Fresh a -> Fresh a
forall a. Semigroup a => NonEmpty (Fresh a) -> Fresh a
forall a. Semigroup a => Fresh a -> Fresh a -> Fresh a
forall a b. (Semigroup a, Integral b) => b -> Fresh a -> Fresh a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Fresh a -> Fresh a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Fresh a -> Fresh a
sconcat :: NonEmpty (Fresh a) -> Fresh a
$csconcat :: forall a. Semigroup a => NonEmpty (Fresh a) -> Fresh a
<> :: Fresh a -> Fresh a -> Fresh a
$c<> :: forall a. Semigroup a => Fresh a -> Fresh a -> Fresh a
Semigroup
      , Semigroup (Fresh a)
Fresh a
Semigroup (Fresh a) =>
Fresh a
-> (Fresh a -> Fresh a -> Fresh a)
-> ([Fresh a] -> Fresh a)
-> Monoid (Fresh a)
[Fresh a] -> Fresh a
Fresh a -> Fresh a -> Fresh a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Fresh a)
forall a. Monoid a => Fresh a
forall a. Monoid a => [Fresh a] -> Fresh a
forall a. Monoid a => Fresh a -> Fresh a -> Fresh a
mconcat :: [Fresh a] -> Fresh a
$cmconcat :: forall a. Monoid a => [Fresh a] -> Fresh a
mappend :: Fresh a -> Fresh a -> Fresh a
$cmappend :: forall a. Monoid a => Fresh a -> Fresh a -> Fresh a
mempty :: Fresh a
$cmempty :: forall a. Monoid a => Fresh a
$cp1Monoid :: forall a. Monoid a => Semigroup (Fresh a)
Monoid, Integer -> Fresh a
Fresh a -> Fresh a
Fresh a -> Fresh a -> Fresh a
(Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Fresh a -> Fresh a)
-> (Integer -> Fresh a)
-> Num (Fresh a)
forall a. Num a => Integer -> Fresh a
forall a. Num a => Fresh a -> Fresh a
forall a. Num a => Fresh a -> Fresh a -> Fresh a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Fresh a
$cfromInteger :: forall a. Num a => Integer -> Fresh a
signum :: Fresh a -> Fresh a
$csignum :: forall a. Num a => Fresh a -> Fresh a
abs :: Fresh a -> Fresh a
$cabs :: forall a. Num a => Fresh a -> Fresh a
negate :: Fresh a -> Fresh a
$cnegate :: forall a. Num a => Fresh a -> Fresh a
* :: Fresh a -> Fresh a -> Fresh a
$c* :: forall a. Num a => Fresh a -> Fresh a -> Fresh a
- :: Fresh a -> Fresh a -> Fresh a
$c- :: forall a. Num a => Fresh a -> Fresh a -> Fresh a
+ :: Fresh a -> Fresh a -> Fresh a
$c+ :: forall a. Num a => Fresh a -> Fresh a -> Fresh a
Num, Eq (Fresh a)
Eq (Fresh a) =>
(Fresh a -> Fresh a -> Ordering)
-> (Fresh a -> Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Fresh a)
-> (Fresh a -> Fresh a -> Fresh a)
-> Ord (Fresh a)
Fresh a -> Fresh a -> Bool
Fresh a -> Fresh a -> Ordering
Fresh a -> Fresh a -> Fresh 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 (Fresh a)
forall a. Ord a => Fresh a -> Fresh a -> Bool
forall a. Ord a => Fresh a -> Fresh a -> Ordering
forall a. Ord a => Fresh a -> Fresh a -> Fresh a
min :: Fresh a -> Fresh a -> Fresh a
$cmin :: forall a. Ord a => Fresh a -> Fresh a -> Fresh a
max :: Fresh a -> Fresh a -> Fresh a
$cmax :: forall a. Ord a => Fresh a -> Fresh a -> Fresh a
>= :: Fresh a -> Fresh a -> Bool
$c>= :: forall a. Ord a => Fresh a -> Fresh a -> Bool
> :: Fresh a -> Fresh a -> Bool
$c> :: forall a. Ord a => Fresh a -> Fresh a -> Bool
<= :: Fresh a -> Fresh a -> Bool
$c<= :: forall a. Ord a => Fresh a -> Fresh a -> Bool
< :: Fresh a -> Fresh a -> Bool
$c< :: forall a. Ord a => Fresh a -> Fresh a -> Bool
compare :: Fresh a -> Fresh a -> Ordering
$ccompare :: forall a. Ord a => Fresh a -> Fresh a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Fresh a)
Ord, Num (Fresh a)
Ord (Fresh a)
(Num (Fresh a), Ord (Fresh a)) =>
(Fresh a -> Rational) -> Real (Fresh a)
Fresh a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (Fresh a)
forall a. Real a => Ord (Fresh a)
forall a. Real a => Fresh a -> Rational
toRational :: Fresh a -> Rational
$ctoRational :: forall a. Real a => Fresh a -> Rational
$cp2Real :: forall a. Real a => Ord (Fresh a)
$cp1Real :: forall a. Real a => Num (Fresh a)
Real, Fractional (Fresh a)
Real (Fresh a)
(Real (Fresh a), Fractional (Fresh a)) =>
(forall b. Integral b => Fresh a -> (b, Fresh a))
-> (forall b. Integral b => Fresh a -> b)
-> (forall b. Integral b => Fresh a -> b)
-> (forall b. Integral b => Fresh a -> b)
-> (forall b. Integral b => Fresh a -> b)
-> RealFrac (Fresh a)
Fresh a -> b
Fresh a -> b
Fresh a -> b
Fresh a -> b
Fresh a -> (b, Fresh a)
forall b. Integral b => Fresh a -> b
forall b. Integral b => Fresh a -> (b, Fresh 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 (Fresh a)
forall a. RealFrac a => Real (Fresh a)
forall a b. (RealFrac a, Integral b) => Fresh a -> b
forall a b. (RealFrac a, Integral b) => Fresh a -> (b, Fresh a)
floor :: Fresh a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Fresh a -> b
ceiling :: Fresh a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Fresh a -> b
round :: Fresh a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Fresh a -> b
truncate :: Fresh a -> b
$ctruncate :: forall a b. (RealFrac a, Integral b) => Fresh a -> b
properFraction :: Fresh a -> (b, Fresh a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => Fresh a -> (b, Fresh a)
$cp2RealFrac :: forall a. RealFrac a => Fractional (Fresh a)
$cp1RealFrac :: forall a. RealFrac a => Real (Fresh a)
RealFrac, Floating (Fresh a)
RealFrac (Fresh a)
(RealFrac (Fresh a), Floating (Fresh a)) =>
(Fresh a -> Integer)
-> (Fresh a -> Int)
-> (Fresh a -> (Int, Int))
-> (Fresh a -> (Integer, Int))
-> (Integer -> Int -> Fresh a)
-> (Fresh a -> Int)
-> (Fresh a -> Fresh a)
-> (Int -> Fresh a -> Fresh a)
-> (Fresh a -> Bool)
-> (Fresh a -> Bool)
-> (Fresh a -> Bool)
-> (Fresh a -> Bool)
-> (Fresh a -> Bool)
-> (Fresh a -> Fresh a -> Fresh a)
-> RealFloat (Fresh a)
Int -> Fresh a -> Fresh a
Integer -> Int -> Fresh a
Fresh a -> Bool
Fresh a -> Int
Fresh a -> Integer
Fresh a -> (Int, Int)
Fresh a -> (Integer, Int)
Fresh a -> Fresh a
Fresh a -> Fresh a -> Fresh a
forall a. RealFloat a => Floating (Fresh a)
forall a. RealFloat a => RealFrac (Fresh a)
forall a. RealFloat a => Int -> Fresh a -> Fresh a
forall a. RealFloat a => Integer -> Int -> Fresh a
forall a. RealFloat a => Fresh a -> Bool
forall a. RealFloat a => Fresh a -> Int
forall a. RealFloat a => Fresh a -> Integer
forall a. RealFloat a => Fresh a -> (Int, Int)
forall a. RealFloat a => Fresh a -> (Integer, Int)
forall a. RealFloat a => Fresh a -> Fresh a
forall a. RealFloat a => Fresh a -> Fresh a -> Fresh 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 :: Fresh a -> Fresh a -> Fresh a
$catan2 :: forall a. RealFloat a => Fresh a -> Fresh a -> Fresh a
isIEEE :: Fresh a -> Bool
$cisIEEE :: forall a. RealFloat a => Fresh a -> Bool
isNegativeZero :: Fresh a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Fresh a -> Bool
isDenormalized :: Fresh a -> Bool
$cisDenormalized :: forall a. RealFloat a => Fresh a -> Bool
isInfinite :: Fresh a -> Bool
$cisInfinite :: forall a. RealFloat a => Fresh a -> Bool
isNaN :: Fresh a -> Bool
$cisNaN :: forall a. RealFloat a => Fresh a -> Bool
scaleFloat :: Int -> Fresh a -> Fresh a
$cscaleFloat :: forall a. RealFloat a => Int -> Fresh a -> Fresh a
significand :: Fresh a -> Fresh a
$csignificand :: forall a. RealFloat a => Fresh a -> Fresh a
exponent :: Fresh a -> Int
$cexponent :: forall a. RealFloat a => Fresh a -> Int
encodeFloat :: Integer -> Int -> Fresh a
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Fresh a
decodeFloat :: Fresh a -> (Integer, Int)
$cdecodeFloat :: forall a. RealFloat a => Fresh a -> (Integer, Int)
floatRange :: Fresh a -> (Int, Int)
$cfloatRange :: forall a. RealFloat a => Fresh a -> (Int, Int)
floatDigits :: Fresh a -> Int
$cfloatDigits :: forall a. RealFloat a => Fresh a -> Int
floatRadix :: Fresh a -> Integer
$cfloatRadix :: forall a. RealFloat a => Fresh a -> Integer
$cp2RealFloat :: forall a. RealFloat a => Floating (Fresh a)
$cp1RealFloat :: forall a. RealFloat a => RealFrac (Fresh a)
RealFloat, (forall x. Fresh a -> Rep (Fresh a) x)
-> (forall x. Rep (Fresh a) x -> Fresh a) -> Generic (Fresh a)
forall x. Rep (Fresh a) x -> Fresh a
forall x. Fresh a -> Rep (Fresh a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Fresh a) x -> Fresh a
forall a x. Fresh a -> Rep (Fresh a) x
$cto :: forall a x. Rep (Fresh a) x -> Fresh a
$cfrom :: forall a x. Fresh a -> Rep (Fresh a) x
Generic, Fresh a -> ()
(Fresh a -> ()) -> NFData (Fresh a)
forall a. NFData a => Fresh a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Fresh a -> ()
$crnf :: forall a. NFData a => Fresh a -> ()
NFData)

-- | Always updated
instance Incremental (Fresh a) where
  type Delta (Fresh a) = a
  patch :: Fresh a -> Delta (Fresh a) -> Fresh a
patch _ = Delta (Fresh a) -> Fresh a
forall a. a -> Fresh a
Fresh
  diff :: Fresh a -> Fresh a -> Maybe (Delta (Fresh a))
diff _ = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> (Fresh a -> a) -> Fresh a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fresh a -> a
forall a. Fresh a -> a
getFresh

#define TRIVIAL_EQ(ty) instance Incremental (ty) where { \
  type Delta (ty) = ty; \
  patch _ x = x; \
  diff a b = if a /= b then Just b else Nothing; \
  }

TRIVIAL_EQ(Bool)
TRIVIAL_EQ(Char)
TRIVIAL_EQ(Double)
TRIVIAL_EQ(Float)
TRIVIAL_EQ(Fixed a)
TRIVIAL_EQ(Int)
TRIVIAL_EQ(Int8)
TRIVIAL_EQ(Int16)
TRIVIAL_EQ(Int32)
TRIVIAL_EQ(Int64)
TRIVIAL_EQ(Integer)
TRIVIAL_EQ(Natural)
TRIVIAL_EQ(Ordering)
TRIVIAL_EQ(Word)
TRIVIAL_EQ(Word8)
TRIVIAL_EQ(Word16)
TRIVIAL_EQ(Word32)
TRIVIAL_EQ(Word64)
TRIVIAL_EQ(Text)
TRIVIAL_EQ(ByteString)