-- |Utils concerning closure construction and application.

module Vectorise.Utils.Closure
  ( mkClosure
  , mkClosureApp
  , buildClosures
  )
where

import Vectorise.Builtins
import Vectorise.Vect
import Vectorise.Monad
import Vectorise.Utils.Base
import Vectorise.Utils.PADict
import Vectorise.Utils.Hoisting

import CoreSyn
import Type
import MkCore
import CoreUtils
import TyCon
import DataCon
import MkId
import TysWiredIn
import BasicTypes( TupleSort(..) )
import FastString


-- |Make a closure.
--
mkClosure :: Type       -- ^ Type of the argument.
          -> Type       -- ^ Type of the result.
          -> Type       -- ^ Type of the environment.
          -> VExpr      -- ^ The function to apply.
          -> VExpr      -- ^ The environment to use.
          -> VM VExpr
mkClosure arg_ty res_ty env_ty (vfn,lfn) (venv,lenv)
 = do dict <- paDictOfType env_ty
      mkv  <- builtin closureVar
      mkl  <- builtin liftedClosureVar
      return (Var mkv `mkTyApps` [arg_ty, res_ty, env_ty] `mkApps` [dict, vfn, lfn, venv],
              Var mkl `mkTyApps` [arg_ty, res_ty, env_ty] `mkApps` [dict, vfn, lfn, lenv])

-- |Make a closure application.
--
mkClosureApp :: Type      -- ^ Type of the argument.
             -> Type      -- ^ Type of the result.
             -> VExpr     -- ^ Closure to apply.
             -> VExpr     -- ^ Argument to use.
             -> VM VExpr
mkClosureApp arg_ty res_ty (vclo, lclo) (varg, larg)
 = do vapply <- builtin applyVar
      lapply <- builtin liftedApplyVar
      lc     <- builtin liftingContext
      return (Var vapply `mkTyApps` [arg_ty, res_ty] `mkApps` [vclo, varg],
              Var lapply `mkTyApps` [arg_ty, res_ty] `mkApps` [Var lc, lclo, larg])

-- |Build a set of 'n' closures corresponding to an 'n'-ary vectorised function.  The length of
-- the list of types of arguments determines the arity.
--
-- In addition to a set of type variables, a set of value variables is passed during closure
-- /construction/.  In contrast, the closure environment and the arguments are passed during closure
-- application.
--
buildClosures :: [TyVar]    -- ^ Type variables passed during closure construction.
              -> [Var]      -- ^ Variables passed during closure construction.
              -> [VVar]     -- ^ Variables in the environment.
              -> [Type]     -- ^ Type of the arguments.
              -> Type       -- ^ Type of result.
              -> VM VExpr
              -> VM VExpr
buildClosures _tvs _vars _env [] _res_ty mk_body
 = mk_body
buildClosures tvs vars env [arg_ty] res_ty mk_body
 =  buildClosure tvs vars env arg_ty res_ty mk_body
buildClosures tvs vars env (arg_ty : arg_tys) res_ty mk_body
 = do { res_ty' <- mkClosureTypes arg_tys res_ty
      ; arg     <- newLocalVVar (fsLit "x") arg_ty
      ; buildClosure tvs vars env arg_ty res_ty'
          . hoistPolyVExpr tvs vars (Inline (length env + 1))
          $ do { lc     <- builtin liftingContext
               ; clo    <- buildClosures tvs vars (env ++ [arg]) arg_tys res_ty mk_body
               ; return $ vLams lc (env ++ [arg]) clo
               }
      }

-- Build a closure taking one extra argument during closure application.
--
-- (clo <x1,...,xn> <f,f^>, aclo (Arr lc xs1 ... xsn) <f,f^>)
--   where
--     f  = \env v -> case env of <x1,...,xn> -> e x1 ... xn v
--     f^ = \env v -> case env of Arr l xs1 ... xsn -> e^ l x1 ... xn v
--
-- In addition to a set of type variables, a set of value variables is passed during closure
-- /construction/.  In contrast, the closure environment and the closure argument are passed during
-- closure application.
--
buildClosure :: [TyVar]         -- ^Type variables passed during closure construction.
             -> [Var]           -- ^Variables passed during closure construction.
             -> [VVar]          -- ^Variables in the environment.
             -> Type            -- ^Type of the closure argument.
             -> Type            -- ^Type of the result.
             -> VM VExpr 
             -> VM VExpr
buildClosure tvs vars vvars arg_ty res_ty mk_body
  = do { (env_ty, env, bind) <- buildEnv vvars
       ; env_bndr <- newLocalVVar (fsLit "env") env_ty
       ; arg_bndr <- newLocalVVar (fsLit "arg") arg_ty

           -- generate the closure function as a hoisted binding
       ; fn <- hoistPolyVExpr tvs vars (Inline 2) $
                 do { lc     <- builtin liftingContext
                    ; body   <- mk_body
                    ; return . vLams lc [env_bndr, arg_bndr]
                             $ bind (vVar env_bndr)
                                    (vVarApps lc body (vvars ++ [arg_bndr]))
                    }

       ; mkClosure arg_ty res_ty env_ty fn env
       }

-- Build the environment for a single closure.
--
buildEnv :: [VVar] -> VM (Type, VExpr, VExpr -> VExpr -> VExpr)
buildEnv [] 
 = do
      ty    <- voidType
      void  <- builtin voidVar
      pvoid <- builtin pvoidVar
      return (ty, vVar (void, pvoid), \_ body -> body)
buildEnv [v] 
 = return (vVarType v, vVar v,
           \env body -> vLet (vNonRec v env) body)
buildEnv vs
 = do (lenv_tc, lenv_tyargs) <- pdataReprTyCon ty

      let venv_con   = tupleCon BoxedTuple (length vs) 
          [lenv_con] = tyConDataCons lenv_tc

          venv       = mkCoreTup (map Var vvs)
          lenv       = Var (dataConWrapId lenv_con)
                       `mkTyApps` lenv_tyargs
                       `mkApps`   map Var lvs

          vbind env body = mkWildCase env ty (exprType body)
                           [(DataAlt venv_con, vvs, body)]

          lbind env body =
            let scrut = unwrapFamInstScrut lenv_tc lenv_tyargs env
            in
            mkWildCase scrut (exprType scrut) (exprType body)
              [(DataAlt lenv_con, lvs, body)]

          bind (venv, lenv) (vbody, lbody) = (vbind venv vbody,
                                              lbind lenv lbody)

      return (ty, (venv, lenv), bind)
  where
    (vvs, lvs) = unzip vs
    tys        = map vVarType vs
    ty         = mkBoxedTupleTy tys
