Необязательные параметры вместе с оператором case

Если я правильно понимаю вашу проблему, то вы можете сделать так:

{-# LANGUAGE GADTs #-}

qlog :: LogResult a => a
qlog = log' []

class LogResult a where
    log' :: [LogArg] -> a

class IsLogArgument a where
    toLogArg :: a -> LogArg

data LogArg = LogLevel LogLevel
            | LogMessage String

data LogLevel = D | I | W | E

instance IsLogArgument LogLevel where
    toLogArg = LogLevel

instance (a ~ Char) => IsLogArgument [a] where
    toLogArg = LogMessage

instance (IsLogArgument arg, LogResult result) => LogResult (arg -> result) where
    log' args arg = log' ((toLogArg arg) : args)

instance (a ~ ()) => LogResult (IO a) where
    log' args = tell "" msg
      where
        tell = case level of
                D -> debugM
                I -> infoM
                W -> warningM
                E -> errorM
        level = fromMaybe I $ look logLevel
        msg   = fromMaybe "No message" $ look logMessage

        logLevel (LogLevel x) = Just x
        logLevel _            = Nothing

        logMessage (LogMessage x) = Just x
        logMessage _              = Nothing

        look = listToMaybe . catMaybes . flip map args

А также:

λ> qlog D "Thing!"
[DEBUG::2017-01-18 20:38:19 EST] Thing!

λ> qlog "Thing!"
[INFO::2017-01-18 20:38:19 EST] Thing!

Фиксированная версия qLog2 будет

qLog2 :: Maybe String -> String -> IO ()
qLog2 l msg =
  case l of
    Just "D" -> debugM "" msg
    Just "I" -> infoM "" msg
    Nothing  -> infoM "" msg

Если бы вы собирались перегрузить qlog, чтобы принять необязательный параметр для уровня, вам нужно было бы использовать класс типов. Эта функция будет раздражать в использовании. Было бы двусмысленно, когда вы пишете qlog "I", если вы ожидаете, что это будет иметь тип String -> IO () или IO (). Может быть, вы создали функцию журнала для информационного уровня, или, может быть, вы записывали сообщение «Я».

Вам нужно только провести анализ случая для аргумента l:

qLog :: Maybe String -> String -> IO ()
qLog l msg = case l of
    Just "D" -> debugM "" msg
    Just "I" -> infoM "" msg
    -- etc.
    Nothing  -> infoM "" msg

(Если вам на самом деле нужно было выполнить анализ случая и для msg, вы можете сделать это с помощью кортежа — case (l, msg) of — как предлагает Алек, или просто заменить оператор case несколькими уравнениями.)

Несвязанные предложения: вместо строк вы можете использовать настраиваемый тип для представления ваших уровней журнала. Это проясняет ситуацию и устраняет риск передачи "G" или "foobar" в качестве уровня журнала.

-- Feel free to use less terse names.
data LogLevel = D | I | W | E
    deriving (Eq, Show)

qLog :: Maybe LogLevel -> String -> IO ()
qLog l msg = case l of
    Just D -> debugM "" msg
    Just I -> infoM "" msg
    Just W -> warningM "" msg
    Just E -> errorM "" msg
    Nothing -> infoM "" msg

Вы также можете исключить большую часть повторяемости:

-- I added a few superflous parentheses to emphasise what is going on.
qLog :: Maybe LogLevel -> String -> IO ()
qLog ml msg = case ml of
     Just l -> (fLog l) "" msg
     Nothing -> infoM "" msg
     where
     fLog :: LogLevel -> (String -> String -> IO ())
     fLog l = case l of
         D -> debugM
         I -> infoM
         W -> warningM
         E -> errorM

Или, используя maybe, чтобы аккуратно исключить возможность:

GHCi> :t maybe
maybe :: b -> (a -> b) -> Maybe a -> b

-- There are also some superflous parentheses here.
qLog :: Maybe LogLevel -> String -> IO ()
qLog ml msg = (maybe infoM fLog ml) "" msg
     where
     fLog :: LogLevel -> (String -> String -> IO ())
     fLog l = case l of
         D -> debugM
         I -> infoM
         W -> warningM
         E -> errorM