{-# language NoImplicitPrelude #-}
{-# options_haddock prune, hide #-}
module Polysemy.Time.Prelude (
module Polysemy.Time.Prelude,
module Data.Foldable,
module Data.Kind,
module GHC.Err,
module Polysemy,
module Polysemy.AtomicState,
module Polysemy.Time.Debug,
module Relude,
) where
import qualified Data.Aeson as Aeson
import Data.Aeson.TH (deriveJSON)
import Data.Fixed (div')
import Data.Foldable (traverse_)
import Data.Kind (Type)
import GHC.Err (undefined)
import qualified Language.Haskell.TH.Syntax as TH
import Polysemy (
Effect,
EffectRow,
Embed,
Final,
InterpreterFor,
Member,
Members,
Sem,
WithTactics,
embed,
embedToFinal,
interpret,
makeSem,
pureT,
raise,
raiseUnder,
raiseUnder2,
raiseUnder3,
reinterpret,
runFinal,
)
import Polysemy.AtomicState (AtomicState, atomicGet, atomicGets, atomicModify', atomicPut, runAtomicStateTVar)
import Relude hiding (
Reader,
State,
Sum,
Type,
ask,
asks,
evalState,
filterM,
get,
gets,
hoistEither,
modify,
modify',
put,
readFile,
runReader,
runState,
state,
trace,
traceShow,
undefined,
)
import Polysemy.Time.Debug (dbg, dbgs, dbgs_)
unit ::
Applicative f =>
f ()
unit :: f ()
unit =
() -> f ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
{-# inline unit #-}
basicOptions :: Aeson.Options
basicOptions :: Options
basicOptions =
Options
Aeson.defaultOptions {
fieldLabelModifier :: String -> String
Aeson.fieldLabelModifier = (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char
'_' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==)
}
jsonOptions :: Aeson.Options
jsonOptions :: Options
jsonOptions =
Options
basicOptions {
unwrapUnaryRecords :: Bool
Aeson.unwrapUnaryRecords = Bool
True
}
defaultJson :: TH.Name -> TH.Q [TH.Dec]
defaultJson :: Name -> Q [Dec]
defaultJson =
Options -> Name -> Q [Dec]
deriveJSON Options
jsonOptions
{-# inline defaultJson #-}
safeDiv ::
Real a =>
Integral a =>
a ->
a ->
Maybe a
safeDiv :: a -> a -> Maybe a
safeDiv a
_ a
0 =
Maybe a
forall a. Maybe a
Nothing
safeDiv a
n a
d =
a -> Maybe a
forall a. a -> Maybe a
Just (a
n a -> a -> a
forall a b. (Real a, Integral b) => a -> a -> b
`div'` a
d)
{-# inline safeDiv #-}
divOr0 ::
Real a =>
Integral a =>
a ->
a ->
a
divOr0 :: a -> a -> a
divOr0 a
l a
r =
a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe a
0 (a -> a -> Maybe a
forall a. (Real a, Integral a) => a -> a -> Maybe a
safeDiv a
l a
r)
{-# inline divOr0 #-}