Debugging ghci错误：“；在该位置未找到断点。”；

我正在尝试跟随到我的堆栈项目，并通过运行

$stack ghci

输入了repl。当我试图在模块

Api.Checklist

中的第207行设置断点时，我得到以下错误

> :break Api.Checklist 207
No breakpoints found at that location.

未设置断点，如

：show breaks

的空结果所示

> :show breaks
No active breakpoints.

为什么

>：中断Api。检查表207

无法设置断点

---

编辑：

根据要求，Api.Checklist的内容如下所示，其中第207行是读取的行

checklistAnswerPG entryId apiAnswer=

{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE ExtendedDefaultRules  #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE TypeOperators         #-}

module Api.Checklist where

import           Control.Monad            (mapM, mapM_)
import           Control.Monad.IO.Class   (liftIO)
import           Data.Aeson               (FromJSON, Value(..),
                                           toJSON, encode)
import qualified Data.HashMap.Strict      as M
import           Data.Text                (Text, pack)
import           Data.Time.Clock          (UTCTime, getCurrentTime)
import           GHC.Generics             (Generic)
import qualified Opaleye                  as O
import           Servant

import           Api.Shared
import           App
import           Models.Checklist
import           Models.ChecklistAnswer
import           Models.ChecklistEntry
import           Models.ChecklistQuestion
import           Models.ChecklistTemplate
import           Models.Validation        (Errors(..), Validatable,
                                           Validation,
                                           ValidationResult (Failure, Success),
                                           errors, failure, keyToField,
                                           validate, validateEntity)
import           Queries.Checklist
import           Types.JWTUser

data ApiAnswer = ApiAnswer { questionId :: Int, answer :: Maybe Bool }
  deriving (Generic)
data ApiChecklistEntryWrite = ApiChecklistEntryWrite { answers :: [ApiAnswer] }
  deriving (Generic)

instance FromJSON ApiAnswer
instance FromJSON ApiChecklistEntryWrite
instance Validatable ApiChecklistEntryWrite where
  validateEntity entry = do
    mapM_ validateAnswer $ answers entry

    where
      validateAnswer :: ApiAnswer -> Validation
      validateAnswer apiAnswer = do
        case answer (apiAnswer :: ApiAnswer) of
          Just _ ->
            return ()

          Nothing ->
            failure (pack $ "answers[questionId=" ++ show (questionId (apiAnswer :: ApiAnswer)) ++ "]") ["must not be null"]


type ChecklistAPI = Get '[JSON] ChecklistRead
               :<|> ReqBody '[JSON] TemplateChecklist :> Patch '[JSON] ChecklistRead
               :<|> "entries" :> Get '[JSON] [ChecklistEntryRead]
               :<|> "entries" :> Capture "checklistEntryId" Int :> Get '[JSON] ChecklistEntryRead
               :<|> "entries" :> ReqBody '[JSON] ApiChecklistEntryWrite :> Post '[JSON] ChecklistEntryRead
               :<|> "questions" :> Get '[JSON] [ChecklistQuestionRead]
               :<|> "entries" :> Capture "entryId" Int :> "answers" :> Get '[JSON] [Value]


checklistAPI :: Servant.Proxy ChecklistAPI
checklistAPI = Servant.Proxy


checklistServer :: JWTUser -> Int -> ServerT ChecklistAPI AppM
checklistServer jwtUser checklistId' = getChecklist jwtUser checklistId'
                                 :<|> updateChecklist jwtUser checklistId'
                                 :<|> getChecklistEntries jwtUser checklistId'
                                 :<|> getChecklistEntry jwtUser checklistId'
                                 :<|> createChecklistEntry jwtUser checklistId'
                                 :<|> getChecklistQuestions jwtUser checklistId'
                                 :<|> getChecklistAnswers jwtUser checklistId'


getChecklist :: JWTUser -> Int -> AppM ChecklistRead
getChecklist _ = singleQuery . checklistQuery


updateChecklist :: JWTUser -> Int -> TemplateChecklist -> AppM ChecklistRead
updateChecklist jwtUser checklistId' template' = withTransaction $ do
  case validate template' of
    Success ->
      go

    Failure es ->
      throwError $ err422 { errBody = encode $ Errors { errors = es } }

  where
    go = do
      originalChecklist <- singleQuery (checklistQuery checklistId')
      let facilityId' = facilityId (originalChecklist :: ChecklistRead)
          checklistWrite = ChecklistWrite { facilityId = facilityId'
                                          , name = name (template' :: TemplateChecklist)
                                          }

      updatedChecklist <- liftIO . checklistToPG $ checklistWrite
      result <- update
                jwtUser
                (Just facilityId')
                checklistTable
                (\_ -> updatedChecklist { Models.Checklist.checklistId = Just $ O.pgInt4 checklistId' })
                (\org -> (Models.Checklist.checklistId org) O..== O.pgInt4 checklistId')

      case result of
        Left err ->
          handleSqlError (keyToField template') err

        Right savedChecklist -> do
          updateQuestions savedChecklist
          return savedChecklist

    updateQuestions savedChecklist = do
      let facilityId' = facilityId (savedChecklist :: ChecklistRead)
      now <- liftIO getCurrentTime
      archivePreviousQuestions now facilityId'
      mapM_ (createQuestion savedChecklist now) $ questions template'
      return ()

    createQuestion :: ChecklistRead -> UTCTime -> TemplateQuestion -> AppM ChecklistQuestionRead
    createQuestion savedChecklist now question' = do
      let facilityId' = facilityId (savedChecklist :: ChecklistRead)
      newChecklistQuestion <-
        liftIO . checklistQuestionToPG now $ ChecklistQuestionWrite
                                             (checklistId (savedChecklist :: ChecklistRead))
                                             (question (question' :: TemplateQuestion))
                                             (description (question' :: TemplateQuestion))
                                             (questionType (question' :: TemplateQuestion))
                                             (position (question' :: TemplateQuestion))
      createOr500
        (keyToField template')
        jwtUser
        (Just facilityId')
        checklistQuestionTable
        newChecklistQuestion

    archivePreviousQuestions now facilityId' = do
      previousQuestions <- query (checklistQuestionsByChecklistAndTimeQuery checklistId' now)
      mapM_ (archiveQuestion now facilityId') previousQuestions

    archiveQuestion :: UTCTime -> Int -> ChecklistQuestionRead -> AppM ChecklistQuestionRead
    archiveQuestion now facilityId' question' = do
      updatedQuestion <- liftIO . checklistQuestionReadToWrite $ question'
      updateOr500 (keyToField template') jwtUser (Just facilityId') checklistQuestionTable
                (\_ -> updatedQuestion { effectiveTo = O.pgUTCTime now })
                (\q -> Models.ChecklistQuestion.checklistQuestionId q O..== O.pgInt4 (Models.ChecklistQuestion.checklistQuestionId question'))



getChecklistEntry :: JWTUser -> Int -> Int -> AppM ChecklistEntryRead
getChecklistEntry _ _ = singleQuery . checklistEntryQuery


getChecklistEntries :: JWTUser -> Int -> AppM [ChecklistEntryRead]
getChecklistEntries _  = query . checklistEntryByChecklistQuery


getChecklistQuestions :: JWTUser -> Int -> AppM [ChecklistQuestionRead]
getChecklistQuestions _ checklistId' =
  query . checklistQuestionsByChecklistAndTimeQuery checklistId' =<< liftIO getCurrentTime


getChecklistAnswers :: JWTUser -> Int -> Int -> AppM [Value]
getChecklistAnswers _ _ id =
  fmap buildJson <$> (query $ checklistAnswersWithQuestionForChecklistEntryQuery id)

  where
    buildJson :: (ChecklistAnswerRead, ChecklistQuestionRead) -> Value
    buildJson (a, q) =
      let
        Object jsonAnswer = toJSON a
        jsonQuestion = toJSON q
      in
        Object (M.insert "checklistQuestion" jsonQuestion jsonAnswer)


createChecklistEntry :: JWTUser -> Int -> ApiChecklistEntryWrite -> AppM ChecklistEntryRead
createChecklistEntry jwtUser cId checklistEntryWrite = do
  checklist <- singleQuery (checklistQuery cId) :: AppM ChecklistRead
  withTransaction $ validateAndCreate (go $ facilityId (checklist :: ChecklistRead)) checklistEntryWrite

  where
    go facId = do
      newChecklistEntry <- liftIO . checklistEntryToPG $ ChecklistEntryWrite cId
      savedChecklistEntry <- create jwtUser (Just facId) checklistEntryTable newChecklistEntry

      case savedChecklistEntry of
        Right checklistEntry -> do
          let newChecklistAnswerPG = checklistAnswerPG $ checklistEntryId (checklistEntry :: ChecklistEntryRead)

          createdAnswers <- mapM newChecklistAnswerPG $ answers checklistEntryWrite
          results <- mapM (create jwtUser (Just facId) checklistAnswerTable) createdAnswers :: AppM [DbResult ChecklistAnswerRead]
          case all isRight results of
            True ->
              return checklistEntry
            False ->
              throwError $ err500 { errBody = "one or more answers failed to save" }

        Left _ ->
          throwError err500

    checklistAnswerPG entryId apiAnswer =
      case answer (apiAnswer :: ApiAnswer) of
        Just a ->
          liftIO $ checklistAnswerToPG $ ChecklistAnswerWrite { checklistEntryId = entryId
                                                              , checklistQuestionId = questionId apiAnswer
                                                              , answer = boolToText a
                                                              }
        Nothing ->
          throwError $ err500 { errBody = "got a null answer, validations should have happened by now" }

    boolToText :: Bool -> Text
    boolToText True  = "true"
    boolToText False = "false"

{-#语言数据类型}
{-#派生通用语言}
{-#语言重复记录字段#-}
{-#语言扩展DefaultRules}
{-#语言灵活语境#-}
{-#语言类型运算符{-}
模块Api。检查表在哪里
导入控制.Monad（mapM，mapM）
导入控制.Monad.IO.Class（liftIO）
导入Data.Aeson（FromJSON，Value（..），
toJSON，encode）
将限定的Data.HashMap.Strict导入为M
导入数据.Text（文本，包）
导入Data.Time.Clock（UTCTime、getCurrentTime）
进口GHC.仿制药（仿制药）
进口合格的蛋白石
进口佣人
导入Api.Shared
导入应用程序
导入模型。检查表
导入模型.ChecklistAnswer
导入模型。ChecklistEntry
导入模型.ChecklistQuestion
导入模型。ChecklistTemplate
导入模型。验证（错误（..），可验证，
验证，
验证结果（失败、成功），
错误，失败，凯托菲尔德，
验证，验证（真实性）
导入查询。检查表
导入类型.JWTUser
数据ApiAnswer=ApiAnswer{questionId:：Int，answer:：maybool}
派生（通用）
数据ApiChecklistEntryWrite=ApiChecklistEntryWrite{answers:：[APIANSERK]}
派生（通用）
实例FromJSON ApiAnswer
来自JSON ApiChecklistEntryWrite的实例
实例可验证ApiChecklistEntryWrite where
validateEntity条目=do
mapM_uu验证应答$answer条目
哪里
validateAnswer:：ApiAnswer->验证
validateAnswer apiAnswer=do
的案例答案（apiAnswer:：apiAnswer）
只是-->
返回（）
没有->
失败（pack$“answers[questionId=“++”show（questionId（apiarse:：apiarse））++“]”[“不能为空”]
键入ChecklistAPI=Get'[JSON]ChecklistRead
：ReqBody'[JSON]TemplateChecklist:>Patch'[JSON]ChecklistRead
：“条目”：>获取“[JSON][ChecklistEntryRead]
：“条目”：>捕获“checklistEntryId”Int:>获取“[JSON]ChecklistEntryRead”
：“条目”：>ReqBody'[JSON]ApiChecklistEntryWrite:>Post'[JSON]ChecklistEntryRead
：“问题”：>获取“[JSON][ChecklistQuestionRead]
：“entries”：>捕获“entryId”Int:>“answers”：>获取“[JSON][Value]
checklistAPI:：Servant.Proxy checklistAPI
checklistAPI=Servant.Proxy
checklistServer:：JWTUser->Int->ServerT ChecklistAPI AppM
checklistServer jwtUser checklistId'=getChecklist jwtUser checklistId'
：updateChecklist jwtUser checklistId'
：getChecklistEntries jwtUser checklistId'
：getChecklistEntry jwtUser checklistId'
：createChecklistEntry jwtUser checklistId'
：getChecklistQuestions jwtUser checklistId'
：getChecklistAnswers jwtUser checklistId'
getChecklist:：JWTUser->Int->AppM ChecklistRead
getChecklist=单查询。checklistQuery
updateChecklist:：JWTUser->Int->TemplateChecklist->AppM ChecklistRead
updateChecklist jwtUser checklistId“模板”=带事务$do
案例验证模板'
成功->
去
失败es->
抛出者$err422{errBody=encode$Errors{Errors=es}
哪里
去做
原始检查表do
updateQuestions savedChecklist
返回savedChecklist
updateQuestions savedChecklist=do
让facilityId'=facilityId（savedChecklist:：ChecklistRead）
现在UTCTime->模板问题->应用程序检查列表问题阅读
createQuestion savedChecklist现在问题'=do
让facilityId'=facilityId（savedChecklist:：ChecklistRead）
newChecklistQuestion updatedQuestion{effectiveTo=O.pgUTCTime now}）
（\q->Models.ChecklistQuestion.checklistQuestionId q O..==O.pgInt4（Models.ChecklistQuestion.checklistQuestionId问题）））
getChecklistEntry:：JWTUser->Int->Int->AppM ChecklistEntryRead
getChecklistEntry\uux=singleQuery。checklistEntryQuery
getChecklistEntries:：JWTUser->Int->AppM[ChecklistEntryRead]
getChecklistEntries=查询。CheckListEntryCheckListQuery
getChecklistQuestions:：JWTUser->Int->AppM[ChecklistQuestionRead]
getChecklistQuestions\uCheckListId'=
查询checklistQuestionsByChecklistAndTimeQuery checklistId'=Int->Int->AppM[Value]
getChecklistAnswers\uID=
fmap buildJson（查询$checklistAnswersWithQuestionForChecklistEntryQuery id）
哪里
buildJson:：（ChecklistAnswerRead，ChecklistQuestionRead）->值
buildJson（a，q）=
让
对象jsonAnswer=toJSON a
jsonQuestion=toJSON-q
在里面
对象（M.insert“checklistQuestion”jsonQuestion jsonAnswer）
createChecklistEntry:：JWTUser->Int->ApiChecklistEntryWrite->AppM ChecklistEntryRead
createChecklistEntry jwtUse