如何使用PureScript Aff编写防御式程序？PureScript新手求教

嘿，作为PureScript新手能关注到防御式编程和Aff的正确用法，这点特别棒！函数式编程里那种强制处理所有可能结果的严谨性，确实是PureScript这类语言的一大优势，而Aff作为处理异步效应的核心工具，正好能帮你把这种严谨性延伸到异步场景中。下面我来分享几个用Aff编写防御式程序的关键技巧：

1. 利用Aff的错误模型，强制处理异步失败 #

Aff内部其实是用ExceptT封装的异步操作，天然支持错误处理——就像你熟悉的Either类型一样，只不过它针对的是异步场景。要写出防御式代码，第一步就是不要忽略任何可能的异步错误，最直接的方式是用try把Aff操作转换成Aff (Either Error a)，这样你就必须显式处理成功（Right）和失败（Left）两种分支：

import Effect.Aff (Aff, try, launchAff_)
import Effect.Console (log)
import Data.Show (show)

-- 模拟一个可能失败的异步操作（比如网络请求）
fetchRemoteData :: Aff String
fetchRemoteData = -- 这里省略具体实现，可能抛出Error

main :: Effect Unit
main = launchAff_ do
  result <- try fetchRemoteData
  case result of
    Left err -> log $ "异步操作失败：" <> show err
    Right data -> log $ "成功获取数据：" <> data

这种写法和你熟悉的Either处理逻辑完全一致，强迫你覆盖所有可能的结果，避免遗漏错误场景。

2. 用catchError做针对性错误处理 #

如果你的程序有多种错误类型（比如网络错误、解析错误），可以自定义错误类型，然后用catchError做精细化处理，而不是统一捕获所有错误。这样能让你的错误逻辑更清晰，也更容易定位问题：

import Effect.Aff (Aff, catchError, launchAff_)
import Effect.Console (log)
import Data.Show (show)

-- 自定义应用级错误类型
data AppError = NetworkError String | JsonParseError String

-- 把原生Error转换成自定义错误（根据实际场景实现）
toAppError :: Error -> AppError
toAppError err = NetworkError $ show err

-- 模拟可能抛出自定义错误的异步操作
fetchAndParseData :: Aff Value
fetchAndParseData = -- 省略实现，可能抛出NetworkError或JsonParseError

-- 针对性处理不同错误
handleAppError :: AppError -> Aff Unit
handleAppError (NetworkError msg) = log $ "网络异常：" <> msg
handleAppError (JsonParseError msg) = log $ "数据解析失败：" <> msg

main :: Effect Unit
main = launchAff_ do
  fetchAndParseData `catchError` (handleAppError <<< toAppError)

3. 结合Either处理同步错误，统一错误流 #

在异步操作中，经常会穿插同步的逻辑（比如解析字符串、验证数据），这些同步操作也可能失败。你可以先用Either处理同步错误，再用fromEither把Either转换成Aff的错误，这样就能把同步和异步错误统一到同一个处理流中：

import Effect.Aff (Aff, fromEither, try, launchAff_)
import Effect.Console (log)
import Data.Either (Either(..))

-- 同步解析JSON，返回Either类型的结果
parseJson :: String -> Either AppError Value
parseJson str = -- 省略实现，成功返回Right，失败返回Left

fetchAndParse :: Aff Value
fetchAndParse = do
  rawStr <- fetchRemoteData -- 异步获取原始字符串
  fromEither $ parseJson rawStr -- 把同步错误转换成Aff错误

main :: Effect Unit
main = launchAff_ do
  result <- try fetchAndParse
  case result of
    Left err -> handleAppError err
    Right value -> log $ "解析后的数据：" <> show value

这样不管是异步请求失败，还是同步解析失败，都能通过同一个错误处理逻辑来处理，代码更一致也更健壮。

4. 用bracket确保资源安全释放 #

防御式编程不仅要处理错误，还要避免资源泄漏（比如打开的文件、网络连接）。Aff提供的bracket函数可以帮你做到：不管操作成功还是失败，都会执行资源清理逻辑。比如处理文件操作：

import Effect.Aff (Aff, bracket, launchAff_)
import Effect.Console (log)
import Effect.File (File, openFile, closeFile, readFile)

-- 安全地打开、使用、关闭文件
withSafeFile :: String -> (File -> Aff String) -> Aff String
withSafeFile filePath action = bracket
  (openFile filePath) -- 获取资源：打开文件
  (\file -> closeFile file) -- 清理资源：不管成败都关闭文件
  action -- 执行实际操作：读取文件内容

main :: Effect Unit
main = launchAff_ do
  content <- withSafeFile "data.txt" readFile
  log $ "文件内容：" <> content

哪怕readFile抛出错误，closeFile也会被执行，绝对不会出现文件句柄泄漏的情况。

5. 避免顶层未处理错误：谨慎使用launchAff_ #

launchAff_会自动捕获顶层的Aff错误并打印，但防御式编程里更推荐在内部处理所有可能的错误，而不是依赖顶层捕获。如果用launchAff（不带下划线），它会返回Effect (Fiber Unit)，此时你需要显式处理fiber的错误，比如用joinFiber或者catchFiber，避免错误被静默忽略。

你提到的“action与handler”的概念，在Aff里其实就是“异步操作”与“错误处理逻辑”的对应——每个可能失败的action，都要有对应的handler来处理失败场景。PureScript的严格性会帮你检查是否遗漏了任何分支，这正是防御式编程的核心：提前覆盖所有可能的异常情况，让程序更健壮。

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