{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}

{-# OPTIONS_GHC -fno-warn-orphans #-}

-- | This module exports 'NFData' instances for 'Some1', 'Some2', 'Some3' and
-- 'Some4' from "Exinst", provided situable 'Dict1', 'Dict2', 'Dict3'
-- and 'Dict4' instances are available.
--
-- See the README file in the @exinst@ package for more general documentation:
-- https://hackage.haskell.org/package/exinst#readme
module Exinst.DeepSeq () where

import Control.DeepSeq (NFData(rnf))
import Data.Constraint
import Data.Kind (Type)
import Prelude

import Exinst.Internal
import Exinst.Internal.Sum
import Exinst.Internal.Product

--------------------------------------------------------------------------------

instance forall k1 (f :: k1 -> Type).
  ( Dict1 NFData f
  ) => NFData (Some1 f) where
  {-# INLINABLE rnf #-}
  rnf :: Some1 f -> ()
rnf = \(!Some1 f
some1x) ->
    forall k1 (f1 :: k1 -> *) r.
Some1 f1
-> (forall (a1 :: k1). SingI a1 => Sing a1 -> f1 a1 -> r) -> r
withSome1Sing Some1 f
some1x forall a b. (a -> b) -> a -> b
$ \ !Sing a1
sa1 !(f a1
x :: f a1) ->
       case forall k0 k1 (c :: k0 -> Constraint) (f1 :: k1 -> k0) (a1 :: k1).
Dict1 c f1 =>
Sing a1 -> Dict (c (f1 a1))
dict1 Sing a1
sa1 :: Dict (NFData (f a1)) of
          Dict (NFData (f a1))
Dict -> forall a. NFData a => a -> ()
rnf f a1
x seq :: forall a b. a -> b -> b
`seq` ()

instance forall k2 k1 (f :: k2 -> k1 -> Type).
  ( Dict2 NFData f
  ) => NFData (Some2 f) where
  {-# INLINABLE rnf #-}
  rnf :: Some2 f -> ()
rnf = \(!Some2 f
some2x) ->
    forall k2 k1 (f2 :: k2 -> k1 -> *) r.
Some2 f2
-> (forall (a2 :: k2) (a1 :: k1).
    (SingI a2, SingI a1) =>
    Sing a2 -> Sing a1 -> f2 a2 a1 -> r)
-> r
withSome2Sing Some2 f
some2x forall a b. (a -> b) -> a -> b
$ \ !Sing a2
sa2 !Sing a1
sa1 !(f a2 a1
x :: f a2 a1) ->
       case forall k0 k2 k1 (c :: k0 -> Constraint) (f2 :: k2 -> k1 -> k0)
       (a2 :: k2) (a1 :: k1).
Dict2 c f2 =>
Sing a2 -> Sing a1 -> Dict (c (f2 a2 a1))
dict2 Sing a2
sa2 Sing a1
sa1 :: Dict (NFData (f a2 a1)) of
          Dict (NFData (f a2 a1))
Dict -> forall a. NFData a => a -> ()
rnf f a2 a1
x seq :: forall a b. a -> b -> b
`seq` ()

instance forall k3 k2 k1 (f :: k3 -> k2 -> k1 -> Type).
  ( Dict3 NFData f
  ) => NFData (Some3 f) where
  {-# INLINABLE rnf #-}
  rnf :: Some3 f -> ()
rnf = \(!Some3 f
some3x) ->
    forall k3 k2 k1 (f3 :: k3 -> k2 -> k1 -> *) r.
Some3 f3
-> (forall (a3 :: k3) (a2 :: k2) (a1 :: k1).
    (SingI a3, SingI a2, SingI a1) =>
    Sing a3 -> Sing a2 -> Sing a1 -> f3 a3 a2 a1 -> r)
-> r
withSome3Sing Some3 f
some3x forall a b. (a -> b) -> a -> b
$ \ !Sing a3
sa3 !Sing a2
sa2 !Sing a1
sa1 !(f a3 a2 a1
x :: f a3 a2 a1) ->
       case forall k0 k3 k2 k1 (c :: k0 -> Constraint)
       (f3 :: k3 -> k2 -> k1 -> k0) (a3 :: k3) (a2 :: k2) (a1 :: k1).
Dict3 c f3 =>
Sing a3 -> Sing a2 -> Sing a1 -> Dict (c (f3 a3 a2 a1))
dict3 Sing a3
sa3 Sing a2
sa2 Sing a1
sa1 :: Dict (NFData (f a3 a2 a1)) of
          Dict (NFData (f a3 a2 a1))
Dict -> forall a. NFData a => a -> ()
rnf f a3 a2 a1
x seq :: forall a b. a -> b -> b
`seq` ()

instance forall k4 k3 k2 k1 (f :: k4 -> k3 -> k2 -> k1 -> Type).
  ( Dict4 NFData f
  ) => NFData (Some4 f) where
  {-# INLINABLE rnf #-}
  rnf :: Some4 f -> ()
rnf = \(!Some4 f
some4x) ->
    forall k4 k3 k2 k1 (f4 :: k4 -> k3 -> k2 -> k1 -> *) r.
Some4 f4
-> (forall (a4 :: k4) (a3 :: k3) (a2 :: k2) (a1 :: k1).
    (SingI a4, SingI a3, SingI a2, SingI a1) =>
    Sing a4 -> Sing a3 -> Sing a2 -> Sing a1 -> f4 a4 a3 a2 a1 -> r)
-> r
withSome4Sing Some4 f
some4x forall a b. (a -> b) -> a -> b
$ \ !(Sing a4
sa4) !Sing a3
sa3 !Sing a2
sa2 !Sing a1
sa1 !(f a4 a3 a2 a1
x :: f a4 a3 a2 a1) ->
       case forall k0 k4 k3 k2 k1 (c :: k0 -> Constraint)
       (f4 :: k4 -> k3 -> k2 -> k1 -> k0) (a4 :: k4) (a3 :: k3) (a2 :: k2)
       (a1 :: k1).
Dict4 c f4 =>
Sing a4
-> Sing a3 -> Sing a2 -> Sing a1 -> Dict (c (f4 a4 a3 a2 a1))
dict4 Sing a4
sa4 Sing a3
sa3 Sing a2
sa2 Sing a1
sa1 :: Dict (NFData (f a4 a3 a2 a1)) of
          Dict (NFData (f a4 a3 a2 a1))
Dict -> forall a. NFData a => a -> ()
rnf f a4 a3 a2 a1
x seq :: forall a b. a -> b -> b
`seq` ()

--------------------------------------------------------------------------------

instance (NFData (l a1), NFData (r a1)) => NFData (S1 l r a1)
instance (NFData (l a2 a1), NFData (r a2 a1)) => NFData (S2 l r a2 a1)
instance (NFData (l a3 a2 a1), NFData (r a3 a2 a1)) => NFData (S3 l r a3 a2 a1)
instance (NFData (l a4 a3 a2 a1), NFData (r a4 a3 a2 a1)) => NFData (S4 l r a4 a3 a2 a1)

--------------------------------------------------------------------------------

instance (NFData (l a1), NFData (r a1)) => NFData (P1 l r a1)
instance (NFData (l a2 a1), NFData (r a2 a1)) => NFData (P2 l r a2 a1)
instance (NFData (l a3 a2 a1), NFData (r a3 a2 a1)) => NFData (P3 l r a3 a2 a1)
instance (NFData (l a4 a3 a2 a1), NFData (r a4 a3 a2 a1)) => NFData (P4 l r a4 a3 a2 a1)