+mkBuiltinTyConApp :: (Builtins -> TyCon) -> [Type] -> VM Type
+mkBuiltinTyConApp get_tc tys
+ = do
+ tc <- builtin get_tc
+ return $ mkTyConApp tc tys
+
+mkBuiltinTyConApps :: (Builtins -> TyCon) -> [Type] -> Type -> VM Type
+mkBuiltinTyConApps get_tc tys ty
+ = do
+ tc <- builtin get_tc
+ return $ foldr (mk tc) ty tys
+ where
+ mk tc ty1 ty2 = mkTyConApp tc [ty1,ty2]
+
+mkBuiltinTyConApps1 :: (Builtins -> TyCon) -> Type -> [Type] -> VM Type
+mkBuiltinTyConApps1 get_tc dft [] = return dft
+mkBuiltinTyConApps1 get_tc dft tys
+ = do
+ tc <- builtin get_tc
+ case tys of
+ [] -> pprPanic "mkBuiltinTyConApps1" (ppr tc)
+ _ -> return $ foldr1 (mk tc) tys
+ where
+ mk tc ty1 ty2 = mkTyConApp tc [ty1,ty2]
+
+data TyConRepr = TyConRepr {
+ repr_tyvars :: [TyVar]
+ , repr_tys :: [[Type]]
+
+ , repr_embed_tys :: [[Type]]
+ , repr_prod_tycons :: [Maybe TyCon]
+ , repr_prod_tys :: [Type]
+ , repr_sum_tycon :: Maybe TyCon
+ , repr_type :: Type
+ }
+
+mkTyConRepr :: TyCon -> VM TyConRepr
+mkTyConRepr vect_tc
+ = do
+ embed_tys <- mapM (mapM mkEmbedType) rep_tys
+ prod_tycons <- mapM (mk_tycon prodTyCon) rep_tys
+ sum_tycon <- mk_tycon sumTyCon rep_tys
+
+ let prod_tys = zipWith mk_tc_app_maybe prod_tycons embed_tys
+
+ return $ TyConRepr {
+ repr_tyvars = tyvars
+ , repr_tys = rep_tys
+
+ , repr_embed_tys = embed_tys
+ , repr_prod_tycons = prod_tycons
+ , repr_prod_tys = prod_tys
+ , repr_sum_tycon = sum_tycon
+ , repr_type = mk_tc_app_maybe sum_tycon prod_tys
+ }
+ where
+ tyvars = tyConTyVars vect_tc
+ data_cons = tyConDataCons vect_tc
+ rep_tys = map dataConRepArgTys data_cons
+
+ mk_tycon get_tc tys
+ | n > 1 = builtin (Just . get_tc n)
+ | otherwise = return Nothing
+ where n = length tys
+
+ mk_tc_app_maybe Nothing [] = unitTy
+ mk_tc_app_maybe Nothing [ty] = ty
+ mk_tc_app_maybe (Just tc) tys = mkTyConApp tc tys
+
+{-
+mkPRepr :: [[Type]] -> VM Type
+mkPRepr tys
+ = do
+ embed_tc <- builtin embedTyCon
+ sum_tcs <- builtins sumTyCon
+ prod_tcs <- builtins prodTyCon
+
+ let mk_sum [] = unitTy
+ mk_sum [ty] = ty
+ mk_sum tys = mkTyConApp (sum_tcs $ length tys) tys
+
+ mk_prod [] = unitTy
+ mk_prod [ty] = ty
+ mk_prod tys = mkTyConApp (prod_tcs $ length tys) tys
+
+ mk_embed ty = mkTyConApp embed_tc [ty]
+
+ return . mk_sum
+ . map (mk_prod . map mk_embed)
+ $ tys
+-}
+
+mkToPRepr :: [[CoreExpr]] -> VM ([CoreExpr], Type)
+mkToPRepr ess
+ = do
+ embed_tc <- builtin embedTyCon
+ embed_dc <- builtin embedDataCon
+ sum_tcs <- builtins sumTyCon
+ prod_tcs <- builtins prodTyCon
+
+ let mk_sum [] = ([Var unitDataConId], unitTy)
+ mk_sum [(expr, ty)] = ([expr], ty)
+ mk_sum es = (zipWith mk_alt (tyConDataCons sum_tc) exprs,
+ mkTyConApp sum_tc tys)
+ where
+ (exprs, tys) = unzip es
+ sum_tc = sum_tcs (length es)
+ mk_alt dc expr = mkConApp dc (map Type tys ++ [expr])
+
+ mk_prod [] = (Var unitDataConId, unitTy)
+ mk_prod [(expr, ty)] = (expr, ty)
+ mk_prod es = (mkConApp prod_dc (map Type tys ++ exprs),
+ mkTyConApp prod_tc tys)
+ where
+ (exprs, tys) = unzip es
+ prod_tc = prod_tcs (length es)
+ [prod_dc] = tyConDataCons prod_tc
+
+ mk_embed expr = (mkConApp embed_dc [Type ty, expr],
+ mkTyConApp embed_tc [ty])
+ where ty = exprType expr
+
+ return . mk_sum $ map (mk_prod . map mk_embed) ess
+
+mkToArrPRepr :: CoreExpr -> CoreExpr -> [[CoreExpr]] -> VM CoreExpr
+mkToArrPRepr len sel ess
+ = do
+ embed_tc <- builtin embedTyCon
+ (embed_rtc, _) <- parrayReprTyCon (mkTyConApp embed_tc [unitTy])
+ let [embed_rdc] = tyConDataCons embed_rtc
+
+ let mk_sum [(expr, ty)] = return (expr, ty)
+ mk_sum es
+ = do
+ sum_tc <- builtin . sumTyCon $ length es
+ (sum_rtc, _) <- parrayReprTyCon (mkTyConApp sum_tc tys)
+ let [sum_rdc] = tyConDataCons sum_rtc
+
+ return (mkConApp sum_rdc (map Type tys ++ (len : sel : exprs)),
+ mkTyConApp sum_tc tys)
+ where
+ (exprs, tys) = unzip es
+
+ mk_prod [(expr, ty)] = return (expr, ty)
+ mk_prod es
+ = do
+ prod_tc <- builtin . prodTyCon $ length es
+ (prod_rtc, _) <- parrayReprTyCon (mkTyConApp prod_tc tys)
+ let [prod_rdc] = tyConDataCons prod_rtc
+
+ return (mkConApp prod_rdc (map Type tys ++ (len : exprs)),
+ mkTyConApp prod_tc tys)
+ where
+ (exprs, tys) = unzip es
+
+ mk_embed expr = (mkConApp embed_rdc [Type ty, expr],
+ mkTyConApp embed_tc [ty])
+ where ty = splitPArrayTy (exprType expr)
+
+ liftM fst (mk_sum =<< mapM (mk_prod . map mk_embed) ess)
+
+mkFromPRepr :: CoreExpr -> Type -> [([Var], CoreExpr)] -> VM CoreExpr
+mkFromPRepr scrut res_ty alts