scary.hs

import Control.Arrow ( (&&&) )
import qualified Control.Arrow ( first, second )
import Data.Maybe ( fromMaybe )

-- this also exists in Data.Graph.Inductive.Query.Monad
(><) :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)
(><) f g = Control.Arrow.first f . Control.Arrow.second g

first :: [a] -> Maybe a
first [] = Nothing
first (x:_) = Just x

rest :: [a] -> [a]
rest [] = error "scoundrel!"
rest (_:xs) = xs

data Command = Cmd deriving (Show) -- or something more useful

lookUpCommand :: String -> Maybe Command
lookUpCommand = undefined  -- or something more useful

fallbackCommand = Cmd -- or something more useful

commandAndRemainingArgs :: [String] -> (Command, [String])
commandAndRemainingArgs args =
    let commandName = first args in
    let maybeCommandAndMaybeRest = ((>>= lookUpCommand) &&& ((rest args) <$)) commandName in
    let commandAndRest = (fromMaybe fallbackCommand >< fromMaybe []) maybeCommandAndMaybeRest in
    commandAndRest

While my original using >>= / &&& / <$ / >< is horrible, I like that it makes a very clear pipeline:

                             lookUpCommand     fallbackCommand
               first            Command?   -->     Command
input [String]  -->  String? < 
                                [String]?  -->     [String]
                                  rest          fallback to []