Haskell：使用 Scotty 跟踪和修改 state HTTP API

Question

我可以通过 Scotty API 使用 IO 修改我的 state 吗？ 目前，我在 IO monad 中有一个 state 转换器，可以根据用户输入修改 state。 但我想通过 Scotty API 来实现。

这是我目前拥有的 state 转换器类型，我用它来不断修改 state 类型并允许 IO 操作。

-- State Transformer type inside IO monad
type STIO st a = STM st IO a

-- State transformer inside a monad
newtype STM st m a = S (st -> m (a, st))

...并使用此提升功能将动作提升到 IO monad 中：

lift :: Monad m => m a -> STM st m a
lift mx = S (\s -> do
    x <- mx
    return (x, s))

这是我目前的基本 Scotty 服务器：

port = 8080

main = server

server :: IO ()
server = do
    print ("Starting Server at port " ++ show port)
    scotty port $ do
        get "/start" $ do
            json ("{starting: "++"True"++"}")

在我的脑海里，我想要一些类似的东西，但不确定如何实现它：

type State = Int

server :: STIO State ()
server = do
    print ("Starting Server at port " ++ show port)
    lift $ scotty port $ do
        get "/start" $ do
            updateCounterByOneInState
            counter <- getCounterFromState
            json $ "{count: " ++ counter ++ "}"

这样的事情甚至可能吗，还是我只是感到困惑？

Answer 1

与所有 WAI 应用程序一样，Scotty 需要准备好在单独的线程中处理多个并发请求。 这给您的STIO monad 带来了一些问题，因为它不直接支持对 state 的并发访问。您需要安排加载 state，运行处理程序，并以并发方式保存 state-安全的。

从技术上讲，您可以借助Web.Scotty.Trans中的函数来完成此操作，但这不是一个好主意。 例如，以下自包含示例将 state 存储在并发安全的MVar中：

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE BangPatterns #-}

import Web.Scotty.Trans as W
import Control.Monad.State as S
import Control.Concurrent.MVar
import Network.Wai.Handler.Warp (Port)
import Data.Text.Lazy (Text)

type STIO s = StateT s IO

scottySTIO :: MVar s -> Port -> ScottyT Text (STIO s) () -> (STIO s) ()
scottySTIO sref p = scottyT p $ \act -> do
  s <- takeMVar sref
  (r, !s') <- runStateT act s
  putMVar sref s'
  return r

server :: STIO Int ()
server = do
  let port = 8080
  liftIO $ print ("Starting Server at port " ++ show port)
  s <- S.get
  sref <- liftIO $ newMVar s
  scottySTIO sref port $ do
    W.get "/start" $ do
      modify (+1)
      counter <- S.get
      json $ "{count: " ++ show counter ++ "}"

main :: IO ()
main = evalStateT server 0

这将“有效”，但它会表现出可怕的并发性能，因为它最终会完整地序列化所有请求，而不仅仅是保护关键代码部分。 只有当您已经在STIO monad 中运行了大量代码，您不想修改任何代码，并且您愿意承受性能损失时，它才真正有意义。

大多数时候，重构您的设计以以并发安全的方式存储 state 并直接从IO访问它会容易得多。 例如，计数器可以存储在单个MVar中并在短临界区中安全访问：

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE BangPatterns #-}

import Web.Scotty
import Control.Concurrent.MVar
import Control.Monad.IO.Class

main :: IO ()
main = do
  let port = 8080
  print ("Starting Server at port " ++ show port)
  sref <- newMVar (0 :: Int)
  scotty port $ do
    get "/start" $ do
      -- start of critical section
      counter <- liftIO $ takeMVar sref
      let !counter' = counter + 1
      liftIO $ putMVar sref counter'
      -- end of critical section
      json $ "{count: " ++ show counter' ++ "}"