Using the Alternative instance of Control.Monad.Except, the following functions:

>>> import Control.Monad.Except

>>> canFail = throwError "it failed" :: Except String Int
>>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

>>> runExcept $ canFail *> final
Left "it failed"
>>> runExcept $ optional canFail *> final
Right 42

instance KDL.DecodeNode Person where
  nodeDecoder = proc () -> do
    name <- KDL.arg -< ()
    returnA -< Person{..}

let
  config =
    """
    person "Alice"
    person "Bob"
    """
  decoder = KDL.document $ proc () -> do
    many $ KDL.node "person" -< ()
KDL.decodeWith decoder config == Right ["Alice", "Bob"]

decoder = KDL.withDecoder KDL.number $ \x -> do
  when (x > 100)
    KDL.failM $ "argument is too large: " <> (Text.pack . show) x
  pure $ MyVal x

decoder = proc () -> do
  KDL.debug -< ()    -- Node{entries = [Entry{}, Entry{}]}
  x <- KDL.arg -< ()
  KDL.debug -< ()    -- Node{entries = [Entry{}]}
  y <- KDL.arg -< ()
  KDL.debug -< ()    -- Node{entries = []}
  returnA -< (x, y)

instance KDL.DecodeNode MyArg where
  nodeDecoder = proc () -> do
    name <- KDL.arg -< ()
    returnA -< MyArg{..}

let
  config =
    """
    build "pkg1"
    build "pkg2"
    lint "pkg1"
    """
  decoder = KDL.document $ proc () -> do
    KDL.remainingNodes -< ()
KDL.decodeWith decoder config == (Right . Map.fromList) [("build", [MyArg "pkg1", MyArg "pkg2"]), ("lint", [MyArg "pkg1"])]

let
  config =
    """
    verbose #true
    """
  decoder = KDL.document $ proc () -> do
    KDL.argAt "verbose" -< ()
KDL.decodeWith decoder config == Right True

let
  config =
    """
    email "aexample.com" "bexample.com"
    """
  decoder = KDL.document $ proc () -> do
    KDL.argsAt "email" -< ()
KDL.decodeWith decoder config == Right ["aexample.com", "bexample.com"]

let
  config =
    """
    attendees {
      - "Alice"
      - "Bob"
    }
    """
  decoder = KDL.document $ proc () -> do
    KDL.dashChildrenAt "attendees" -< ()
KDL.decodeWith decoder config == Right ["Alice", "Bob"]

instance KDL.DecodeNode Attendee where
  nodeDecoder = proc () -> do
    name <- KDL.arg -< ()
    returnA -< Attendee{..}

let
  config =
    """
    attendees {
      - "Alice"
      - "Bob"
    }
    """
  decoder = KDL.document $ proc () -> do
    KDL.dashNodesAt "attendees" -< ()
KDL.decodeWith decoder config == Right [Attendee "Alice", Attendee "Bob"]

let
  config =
    """
    person "Alice"
    person "Bob"
    """
  decoder = KDL.document $ proc () -> do
    many . KDL.nodeWith "person" $ KDL.arg -< ()
KDL.decodeWith decoder config == Right ["Alice", "Bob"]

let
  config =
    """
    build "pkg1"
    build "pkg2"
    lint "pkg1"
    """
  decoder = KDL.document $ proc () -> do
    KDL.remainingNodesWith $ KDL.arg -< ()
KDL.decodeWith decoder config == (Right . Map.fromList) [("build", ["pkg1", "pkg2"]), ("lint", ["pkg1"])]

let
  config =
    """
    verbose #true
    """
  decoder = KDL.document $ proc () -> do
    KDL.argAtWith "verbose" KDL.bool -< ()
KDL.decodeWith decoder config == Right True

let
  config =
    """
    email "aexample.com" "bexample.com"
    """
  decoder = KDL.document $ proc () -> do
    KDL.argsAtWith "email" KDL.string -< ()
KDL.decodeWith decoder config == Right ["aexample.com", "bexample.com"]

let
  config =
    """
    attendees {
      - "Alice"
      - "Bob"
    }
    """
  decoder = KDL.document $ proc () -> do
    KDL.dashChildrenAtWith "attendees" $ KDL.string -< ()
KDL.decodeWith decoder config == Right ["Alice", "Bob"]

let
  config =
    """
    attendees {
      - "Alice"
      - "Bob"
    }
    """
  decoder = KDL.document $ proc () -> do
    KDL.dashNodesAtWith "attendees" KDL.arg -< ()
KDL.decodeWith decoder config == Right [Alice, Bob]

let
  config =
    """
    person "Alice" 1 2 3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "person" $ decodePerson -< ()
  decodePerson = proc () -> do
    name <- KDL.arg -< ()
    vals <- KDL.many KDL.arg -< ()
    returnA -< (name, vals)
KDL.decodeWith decoder config == Right ("Alice", [1, 2, 3])

let
  config =
    """
    my-node a=1 b=2 a=3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "my-node" $ KDL.prop @Int "a" -< ()
KDL.decodeWith decoder config == Right 3

let
  config =
    """
    my-node a=1 b=2 a=3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "my-node" $ KDL.remainingProps @Int -< ()
KDL.decodeWith decoder config == (Right . Map.fromList) [("a", 3), ("b", 2)]

let
  config =
    """
    person "Alice" {
      email "alice@example.com"
    }
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "person" decodePerson -< ()
  decodePerson = proc () -> do
    name <- KDL.arg -< ()
    email <- KDL.children $ KDL.argAt "email" -< ()
    returnA -< Person{..}
KDL.decodeWith decoder config == Right Person{name = "Alice", email = "alice@example.com"}

let
  config =
    """
    person "Alice" 1 2 3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "person" $ decodePerson -< ()
  decodePerson = proc () -> do
    name <- KDL.argWith $ Text.toUpper <$> KDL.string -< ()
    vals <- KDL.many $ KDL.argWith $ show <$> KDL.valueDecoder @Int -< ()
    returnA -< (name, vals)
KDL.decodeWith decoder config == Right ("ALICE", ["1", "2", "3"])

let
  config =
    """
    my-node a=1 b=2 a=3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "my-node" $ KDL.propWith "a" $ show <$> KDL.number -< ()
KDL.decodeWith decoder config == Right "3.0"

let
  config =
    """
    my-node a=1 b=2 a=3
    """
  decoder = KDL.document $ proc () -> do
    KDL.nodeWith "my-node" $ KDL.remainingPropsWith $ show <$> KDL.number -< ()
KDL.decodeWith decoder config == (Right . Map.fromList) [("a", "3.0"), ("b", "2.0")]