Prairie.hs

-- | A library for first-class record fields.
--
-- @since 0.0.1.0
module Prairie
  ( module Prairie.Class
  , module Prairie.Update
  , module Prairie.Diff
  , module Prairie.Fold
  , module Prairie.Traverse
  , module Prairie.Zip
  , module Prairie.TH
  , module Prairie.Semigroup
  , module Prairie.Monoid
  --
  , Prairie (Prairie)
  , type (~>)
  , prairie
  , distribute
  , tabulate
  , components
  , Prairie.zipWith
  , Prairie.unzip
  , constants
  , toList
  , labelled
  ) where

import Prairie.Class
import Prairie.Diff
import Prairie.Fold
import Prairie.Monoid
import Prairie.Semigroup
import Prairie.TH
import Prairie.Traverse
import Prairie.Update
import Prairie.Zip

--
import Control.Lens
import Data.Functor.Const
import Data.Functor.Identity
import Data.Functor.Product
import Data.Kind
import Data.Text (Text)
import GHC.Records

newtype Prairie rec f = Prairie (forall ty. Field rec ty -> f ty)

instance (SymbolToField sym rec ty) => HasField sym (Prairie rec f) (f ty) where
  getField (Prairie f) = f (symbolToField @sym)

type f ~> g = forall x. f x -> g x
infixr 9 ~>

prairie :: (Record rec) => Iso' rec (Prairie rec Identity)
prairie = iso (distribute . Identity) (runIdentity . tabulate)

distribute :: (Record rec, Functor f) => f rec -> Prairie rec f
distribute frec = Prairie \field -> getRecordField field <$> frec

tabulate :: (Record rec, Applicative f) => Prairie rec f -> f rec
tabulate (Prairie f) = tabulateRecordA f

components ::
  (Record rec) => (forall x. f x -> g x) -> Prairie rec f -> Prairie rec g
components nat (Prairie f) = Prairie (nat . f)

zipWith ::
  (Record rec) =>
  (forall x. f x -> g x -> h x) ->
  (Prairie rec f -> Prairie rec g -> Prairie rec h)
zipWith nat (Prairie f) (Prairie g) = Prairie (liftA2 nat f g)

zip ::
  (Record rec) => Prairie rec f -> Prairie rec g -> Prairie rec (Product f g)
zip = Prairie.zipWith Pair

unzip ::
  (Record rec) => Prairie rec (Product f g) -> (Prairie rec f, Prairie rec g)
unzip (Prairie p) =
  ( Prairie \field -> let Pair f _ = p field in f
  , Prairie \field -> let Pair _ g = p field in g
  )

constants ::
  forall x rec.
  (Record rec) =>
  (forall ty. Field rec ty -> x) ->
  Prairie rec (Const x)
constants f = Prairie \field -> Const (f field)

toList :: forall x rec. (Record rec) => Prairie rec (Const x) -> [x]
toList (Prairie f) = getConst . tabulate $ constants \field -> [getConst $ f field]

labelled ::
  forall x rec. (Record rec) => Prairie rec (Const x) -> [(Text, x)]
labelled (Prairie values) = getConst . tabulate $ constants \field ->
  [(recordFieldLabel field, getConst $ values field)]