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