{-# options_haddock hide #-}
{-# LANGUAGE NoImplicitPrelude #-}

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 #-}