{-# LANGUAGE NoImplicitPrelude #-}
-- | Commonly useful functions, a Prelude replacement.
module Com.Simatime.Alpha
  (
  -- * Re-export Protolude
    module X
  -- * Applying
  , (<|)
  , (|>)
  -- * Mapping
  , (/>)
  , (</)
  , (<//)
  -- * Debugging tools
  , say
  -- * TODO: remove this
  , Prelude.read
  )
where

import           Data.Function                  ( (&) )
import           Data.Functor                   ( (<&>) )
import           Data.String
import           Data.Text                      ( Text )
import qualified Prelude
import           Protolude                     as X

-- | Debugging printf
say :: Text -> IO ()
say msg = putStrLn msg

-- $operators
--
-- Operators have a pattern to their characters
--
-- `|` normal function-level applications
-- `/` indicates doing something inside a functor
-- `<` and `>` indicate the direction in which values flow btw functions

-- | Alias for map, fmap, <$>
(</) :: Functor f => (a -> b) -> f a -> f b
(</) = fmap

-- | Double fmap. A function on the left goes "into" two functors
-- (i.e. it goes "two levels deep"), applies the function to the inner
-- values, then returns the result wrapped in the two functors.
(<//) :: (Functor f0, Functor f1) => (a -> b) -> f0 (f1 a) -> f0 (f1 b)
(<//) = fmap . fmap

-- | Normal function application. Do the right side, then pass the
-- return value to the function on the left side.
(<|) :: (a -> b) -> a -> b
(<|) = ($)
infixr 0 <|

-- | Reverse function application. Do the left side, then pass the
-- return value to the function on the right side.
(|>) :: a -> (a -> b) -> b
(|>) = (&)

-- | Alias for <&>. Can be read as "and then". Basically does into a
-- functor, does some computation, then returns the same kind of
-- functor. Could also be defined as `f >>= return . g`
(/>) :: Functor f => f a -> (a -> b) -> f b
(/>) = (<&>)