isLitTy,

         getRuntimeRep, splitRuntimeRep_maybe, kindRep_maybe, kindRep,

         mkCastTy, mkCoercionTy, splitCastTy_maybe,

     -- the isLiftedTypeKind check is necessary b/c of Constraint

     isConcreteType k

 -- | Tests whether the given type is concrete, i.e. it

 -- whether it consists only of concrete type constructors,

 -- concrete type variables, and applications.

 -- Convert the argument to the given type, and wrap the conversion

 -- around the given expression. Use the given Id as a name for the

 -- converted value.

 castArgRename :: [(PrimOp,Type,Unique)] -> StgArg -> StgExpr -> StgExpr

 castArgRename ops in_arg rhs =

   case ops of

 mkCastVar :: Unique -> Type -> Id

 mkCastVar uq ty = mkSysLocal (fsLit "cst_sum") uq ManyTy ty

 mkCast :: StgArg -> PrimOp -> OutId -> StgKind -> StgExpr -> StgExpr

 mkCast arg_in cast_op out_id out_kind in_rhs =

   let scrut = StgOpApp (StgPrimOp cast_op) [arg_in]

       alt = GenStgAlt { alt_con = DEFAULT, alt_bndrs = [], alt_rhs = in_rhs}

   in (StgCase scrut out_id alt_ty [alt])

 -- | Build a unboxed sum term from arguments of an alternative.

 import qualified Data.Map.Strict as Map

 import qualified Data.IntMap.Strict as I

 import qualified Data.Semigroup (Semigroup(..))

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

 --

                   ; emitAssign (CmmLocal reg) e

                   ; return reg }

 -- Choose suitable local regs to use for the components

 -- of an unboxed tuple that we are about to return to

 -- the Sequel.  If the Sequel is a join point, using the

 -- regs it wants will save later assignments.

 newUnboxedTupleRegs res_kind

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

 --      emitMultiAssign

   where

     result       = result_reps `zip` result_slots

     result_slots = fmap (slotCount . primRepSize) result_reps

 -- | Ensure that the set of identifiers has valid 'RuntimeRep's. This function

 -- returns a no-op when 'csRuntimeAssert' in 'StgToJSConfig' is False.

     countFunRepArgs, countConRepArgs, dataConRuntimeRepStrictness,

     tyConPrimRep,

     runtimeRepPrimRep_maybe, kindPrimRep_maybe, typePrimRep_maybe,

     -- * Unboxed sum representation type

     ubxSumRepType, layoutUbxSum, repSlotTy, SlotTy (..),

 -- no runtime representation (void) or multiple (unboxed tuple/sum)

 -- See also Note [Getting from RuntimeRep to PrimRep]

 typePrimRep :: HasDebugCallStack => Type -> [PrimRep]

 -- | Discovers the primitive representation of a 'Type'. Returns

 -- a list of 'PrimRep': it's a list because of the possibility of

 -- See also Note [Getting from RuntimeRep to PrimRep]

 tyConPrimRep :: HasDebugCallStack => TyCon -> [PrimRep]

 tyConPrimRep tc

   where

     res_kind = tyConResKind tc

 -- | Take a kind (of shape @TYPE rr@) and produce the 'PrimRep's

 -- of values of types of this kind.

 -- See also Note [Getting from RuntimeRep to PrimRep]

 -- NB: We could implement the partial methods by calling into the maybe

 -- variants here. But then both would need to pass around the doc argument.