混合Either与Maybe Monad：不同类型Monad组合执行操作技术问询

Got it, let's tackle this problem step by step. Since you already know how to chain same-type Monads, combining Either and Maybe just requires bridging their contexts—either by converting one to match the other or using a Monad Transformer. I'll use Haskell for examples (the standard language for Monad discussions) to make this concrete.

Step 1: Define Your Validation/Transformation Functions #

First, let's formalize the two functions with their respective Monad types:

import Data.List (isInfixOf)

-- 1. Checks if input contains "Jo"; returns Maybe String (Just with appended "Bob" if valid, Nothing otherwise)
containsJo :: String -> Maybe String
containsJo s
  | "Jo" `isInfixOf` s = Just (s ++ "Bob")
  | otherwise = Nothing

-- 2. Checks if string length > 8; returns Either String String (Right if valid, Left with error message otherwise)
lengthOver8 :: String -> Either String String
lengthOver8 s
  | length s > 8 = Right s
  | otherwise = Left "Error: String length is not greater than 8"

Step 2: Bridge the Monad Contexts #

Approach 1: Convert Maybe to Either (Simplest for This Use Case) #

Since Maybe can be seen as a simplified Either (only tracking success/failure without error details), we can convert the Maybe result from containsJo to an Either with a custom error message. This lets us chain both operations in the Either Monad context.

First, create a helper to convert Maybe to Either:

-- Converts Maybe a to Either e a, using the provided error for Nothing cases
maybeToEither :: e -> Maybe a -> Either e a
maybeToEither err Nothing = Left err
maybeToEither _ (Just x) = Right x

Now implement the hello function using do-notation (Monad chaining):

hello :: String -> Either String String
hello input = do
  -- Convert Maybe result to Either, with error for missing "Jo"
  step1Result <- maybeToEither "Error: Input does not contain 'Jo'" (containsJo input)
  -- Run the length check on the valid step 1 result
  _ <- lengthOver8 step1Result
  -- Return success message if both steps pass
  return "Hello"

Approach 2: Use Monad Transformers (For More Complex Scenarios) #

If you're working with nested Monad contexts regularly, Monad Transformers are a cleaner approach. Here we'll use MaybeT (a transformer that wraps an underlying Monad, like Either) to handle the Maybe failure while preserving Either's error details.

import Control.Monad.Trans.Maybe
import Control.Monad.Trans.Class

helloTransformer :: String -> Either String String
helloTransformer input = case runMaybeT validationChain of
  Right (Just _) -> Right "Hello"  -- Both steps succeeded
  Right Nothing -> Left "Error: Input does not contain 'Jo'"  -- Maybe step failed
  Left err -> Left err  -- Either step failed
  where
    validationChain :: MaybeT (Either String) ()
    validationChain = do
      -- Run the Maybe-valued check inside MaybeT
      step1 <- MaybeT $ return $ containsJo input
      -- Lift the Either-valued check into the MaybeT context
      _ <- lift $ lengthOver8 step1
      return ()

How It Works #

• Approach 1 is straightforward: we normalize both operations into the Either Monad, which supports detailed error messages, making it easy to chain with >>= or do-notation.
• Approach 2 is better for larger codebases where you might mix multiple Monad types; it keeps each operation in its native Monad while using the transformer to unify the context.

Testing these functions:

• hello "Joanna" → Right "Hello" (contains "Jo", becomes "JoannaBob" which is length 9 >8)
• hello "John" → Left "Error: String length is not greater than 8" (becomes "JohnBob" which is length 7)
• hello "Alice" → Left "Error: Input does not contain 'Jo'"

内容的提问来源于stack exchange，提问作者sandwood