正如@Poselsky所指出的，使用Text.Megaparsec.Char.Lexer的要点是，您不需要（也不应该）在更高级别的解析器中处理白色。因此，我首先删除lamAbs和definition中的space的每次使用，从commandEval中删除optional newline，并在term中将sepBy1 xxx sc替换为some xxx。（在所有这些情况下，这些解析器不执行任何功能。在前面的词素解析器已经吸收了所有尾随空格之后，它们在输入流上运行。）
我也会把lexeme调用移到lowercaseWord中：

lowercaseWord :: Parser [Char]
lowercaseWord = lexeme (some lowerChar)

然后，除了原始解析器（现在是symbol和lowercaseWord），唯一需要处理空白的地方是顶级解析器program开始处的sc。应该假设所有其他解析器都从非空白开始并吸收尾随的空白，并且这些解析器可以按顺序组合以创建遵循相同规则的另一个解析器，因此不需要杂散的space或sc或newline调用。
这将简化您的代码，尽管它不会解决您的问题。
你的尝试修复是正确的想法。问题是它不能解析newdef * 之前的最后一个变量，因为variable * 后面是newdef。
实际上，您不需要尝试解析整个定义。你真正需要做的就是确保variable后面没有symbol "="，你需要把它 Package 在try块中，以回溯variable解析的名称：

term :: Parser Term
term = foldl1 App <$> some (parens term <|> try lamAbs <|>
                            try (variable <* notFollowedBy (symbol "=")))
  where parens = between (symbol "(") (symbol ")")

请注意，您的解析器仍然存在一些问题。例如，它接受以下输入，这可能是您不期望的：

x = lambdalicious. man

(Note这与删除space调用没有任何关系--您原来的解析器也解析了它。
问题是symbol "lambda"可以匹配较大单词的前缀，因此"lambdalicious"被解析为"lambda licious"。如果您不希望":eval"解析为":e val"，则symbol ":e"也存在类似的问题。
通常的解决方案是定义：

reserved :: Text -> Parser Text
reserved s = lexeme $ try (string s <* notFollowedBy lowerChar)

然后按预期进行以下工作：

reserved "lambda"
reserved ":e"

以下是我的完整测试程序，包含了所有上述修订：

{-# LANGUAGE OverloadedStrings #-}

module LambdaParser where

import Data.Void

import Data.Functor
import Data.Text (Text)
import Text.Megaparsec hiding (parse)
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L

type Parser = Parsec Void Text

data Term = Var String | Instruction Term | Abs String Term | App Term Term deriving (Show)
data Instruction t = IDef String t | IEval Term deriving (Show)

sc :: Parser ()
sc = L.space space1 (L.skipLineComment "--") (L.skipBlockComment "{-" "-}")

lexeme :: Parser a -> Parser a
lexeme = L.lexeme sc

symbol :: Text -> Parser Text
symbol = L.symbol sc

reserved :: Text -> Parser Text
reserved s = lexeme $ try (string s <* notFollowedBy lowerChar)

semicolon :: Parser Text
semicolon = symbol ";"

lowercaseWord :: Parser [Char]
lowercaseWord = lexeme (some lowerChar)

variable :: Parser Term
variable = lowercaseWord <&> Var

lamAbs :: Parser Term
lamAbs = do
  reserved "lambda"
  v <- lowercaseWord
  symbol "."
  t <- term
  return $ Abs v t

term :: Parser Term
term = foldl1 App <$> some (parens term <|> try lamAbs <|>
                            try (variable <* notFollowedBy (symbol "=")))
  where parens = between (symbol "(") (symbol ")")

definition :: Parser (Instruction Term)
definition = do
  n <- lowercaseWord
  symbol "="
  t <- term
  return $ IDef n t

commandEval :: Parser (Instruction Term)
commandEval = do
  reserved ":e"
  t <- term
  return $ IEval t

program :: Parser [Instruction Term]
program = sc *> some (definition <|> commandEval) <* eof

parse :: Text -> Either String [Instruction Term]
parse text = case runParser program "" text of
  Left err  -> Left $ errorBundlePretty err
  Right ast -> Right ast

main = do
  let ex1 = "a = (lambda x . x)\n   x\n\n:e b a\n\nb = lambda y . y"
  case parse ex1 of
    Left err -> putStrLn err
    Right pgm -> print pgm