content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE QualifiedDo #-}
  {-# LANGUAGE OverloadedLabels #-}
  {-# LANGUAGE OverloadedLists #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE RebindableSyntax #-}
  {-# LANGUAGE TypeApplications #-}
  module Main where
  
  import Control.Monad (when, return)
  import Data.Bool
  import Data.Function (($))
  import Debug.Trace (traceShow)
  import GHC.Stack
  import GHC.Types (Symbol)
  import System.IO (IO, print)
  import qualified Control.Monad
  
  fromString :: HasCallStack => a -> CallStack
  fromString _ = callStack
  
  fromInteger :: HasCallStack => a -> CallStack
  fromInteger _ = callStack
  
  fromRational :: HasCallStack => a -> CallStack
  fromRational _ = callStack
  
  fromListN :: HasCallStack => len -> a -> CallStack
  fromListN _len _ = callStack
  
  fromLabel :: forall (_lbl::Symbol). HasCallStack => CallStack
  fromLabel = callStack
  
  ifThenElse :: HasCallStack => Bool -> a -> a -> CallStack
  ifThenElse cond _ok _ko | cond = callStack
                          | otherwise = callStack
  
  (>>) :: HasCallStack => a -> b -> CallStack
  (>>) _a _b = callStack
  
  negate :: HasCallStack => a -> CallStack
  negate _a = callStack
  
  (==) :: HasCallStack => a -> b -> Bool
  (==) _a _b = traceShow callStack True
  
  main :: IO ()
  main = Control.Monad.do
  
    -- These come out on stdout
    print $ fromString "str"
    print $ "str"
    print $ fromLabel @"lbl"
    print $ #lbl
    print $ fromInteger 42
    print $ 42
    print $ fromRational 4.2
    print $ 4.2
    print $ fromListN () []
    print $ []
    print $ ifThenElse True () ()
    print $ if True then () else ()
    print $ negate 42
    print $ -42
    print $ () >> ()
    print $ do { (); () }
  
    -- These two come out in stderr, from traceShow
    when (42 == 42) $ return ()
    case 42 of
      42 -> return ()
    return ()
  