{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE GADTs           #-}
{-# LANGUAGE RankNTypes      #-}

-- | Low-level reflection utility for internal use.
--
-- Intended for qualified import:
--
-- > import Data.Record.Anon.Internal.Reflection (Reflected(..))
-- > import qualified Data.Record.Anon.Internal.Reflection as Unsafe
module Data.Record.Anon.Internal.Reflection (
    Reflected(..)
  , reflectKnownFields
  , reflectAllFields
  , reflectSubRow
  , reflectRowHasField
  ) where

import Data.Record.Anon.Plugin.Internal.Runtime

{-------------------------------------------------------------------------------
  Dictionary
-------------------------------------------------------------------------------}

-- | Evidence of some constraint @c@
--
-- This is like 'Data.Record.Anon.Dict', but without the functor argument.
data Reflected c where
  Reflected :: c => Reflected c

{-------------------------------------------------------------------------------
  Reflection
-------------------------------------------------------------------------------}

newtype WK r     = MkWK (KnownFields r     => Reflected (KnownFields r))
newtype WA r c   = MkWA (AllFields r c     => Reflected (AllFields r c))
newtype WS r r'  = MkWS (SubRow r r'       => Reflected (SubRow r r'))
newtype WR n r a = MkWR (RowHasField n r a => Reflected (RowHasField n r a))

reflectKnownFields :: DictKnownFields k r     -> Reflected (KnownFields r)
reflectAllFields   :: DictAllFields k r c     -> Reflected (AllFields r c)
reflectSubRow      :: DictSubRow k r r'       -> Reflected (SubRow r r')
reflectRowHasField :: DictRowHasField k n r a -> Reflected (RowHasField n r a)

reflectKnownFields :: DictKnownFields k r -> Reflected (KnownFields r)
reflectKnownFields DictKnownFields k r
f = WK Any -> DictKnownFields k r -> Reflected (KnownFields r)
forall a b. a -> b
noInlineUnsafeCo ((KnownFields Any => Reflected (KnownFields Any)) -> WK Any
forall (r :: Row *).
(KnownFields r => Reflected (KnownFields r)) -> WK r
MkWK KnownFields Any => Reflected (KnownFields Any)
forall (c :: Constraint). c => Reflected c
Reflected) DictKnownFields k r
f
reflectAllFields :: DictAllFields k r c -> Reflected (AllFields r c)
reflectAllFields   DictAllFields k r c
f = WA Any Any -> DictAllFields k r c -> Reflected (AllFields r c)
forall a b. a -> b
noInlineUnsafeCo ((AllFields Any Any => Reflected (AllFields Any Any)) -> WA Any Any
forall (r :: Row *) (c :: * -> Constraint).
(AllFields r c => Reflected (AllFields r c)) -> WA r c
MkWA AllFields Any Any => Reflected (AllFields Any Any)
forall (c :: Constraint). c => Reflected c
Reflected) DictAllFields k r c
f
reflectSubRow :: DictSubRow k r r' -> Reflected (SubRow r r')
reflectSubRow      DictSubRow k r r'
f = WS Any Any -> DictSubRow k r r' -> Reflected (SubRow r r')
forall a b. a -> b
noInlineUnsafeCo ((SubRow Any Any => Reflected (SubRow Any Any)) -> WS Any Any
forall (r :: Row *) (r' :: Row *).
(SubRow r r' => Reflected (SubRow r r')) -> WS r r'
MkWS SubRow Any Any => Reflected (SubRow Any Any)
forall (c :: Constraint). c => Reflected c
Reflected) DictSubRow k r r'
f
reflectRowHasField :: DictRowHasField k n r a -> Reflected (RowHasField n r a)
reflectRowHasField DictRowHasField k n r a
f = WR Any Any Any
-> DictRowHasField k n r a -> Reflected (RowHasField n r a)
forall a b. a -> b
noInlineUnsafeCo ((RowHasField Any Any Any => Reflected (RowHasField Any Any Any))
-> WR Any Any Any
forall (n :: Symbol) (r :: Row *) a.
(RowHasField n r a => Reflected (RowHasField n r a)) -> WR n r a
MkWR RowHasField Any Any Any => Reflected (RowHasField Any Any Any)
forall (c :: Constraint). c => Reflected c
Reflected) DictRowHasField k n r a
f