You should use the following imports

  import qualified Data.Forced as DF
  import Data.Forced hiding (pure, fmap, (*), return, (>>=), (>>))

The main way this library helps you avoid leaks is by specifying the types of your long lived data structures. They should contain new demands on the type variables.

import Data.Map.Lazy -- it is fine, really.
import Data.Vector

-- On insertion of the lazy map, the keys and the values will evaluated.
type MyMap a = Map (ForcedWHNF Char) (ForcedNF (Maybe (Vector Int)))

-- On top, prompt removal of deleted elements.
type MyMap2 a = ForcedWHNF (Map (ForcedWHNF Char) (ForcedNF (Maybe (Vector Int))))

This way it will be a type error to store a thunk that is keeping references alive.

We use the Demand monad to construct values with the correct strictness. You either construct the values by hand, but it is better to use the -XQualifiedDo extension.

The main functions to keep in mind on this monad are: demandWHNF and demandNF.

Once you have the value specified, you need to extract it to the IO environment. Hopefully this will be close to main where your long lived data should be stored. We do this as is the obvious sequence point, so from the PoV of the rest of the program, the action is visible on the default lifted environment.

The ideal code piece looks like this:

{-# Language QualifiedDo #-}

import qualified Data.Forced as DF
import Data.Forced hiding (pure, fmap, (<*>), return, (>>=), (>>))
import Data.Map.Lazy qualified as ML

noThunksForWHNF :: IO ()
noThunksForWHNF = do
    -- map0 actually evaluated on here.
    let map0 :: Demand (ML.Map Char (ForcedWHNF Int))
        map0 = DF.do
          v <- demandWHNF (const (2 + (2 :: Int)) 'a')
          DF.pure $ ML.insert 'a' v ML.empty

    map1 <- extractDemand map0
    go (ML.lookup 'a' map1)

-- pattern matching for de-structuring, no construction allowed.
go :: ForcedWHNF Int -> IO ()
go (ForcedWHNF i) =  print i

These are available to construct value by hand. But they clash with Functor, Applicative and Monad functions. We cannot provide instances to those classes as the Demand monad is UnliftedType kinded. But using -XQualifiedDo, GHC will pick up these names and use it on a DF.do notation that does the right thing.