Изучение Haskell Parsec и работа с необязательными парсерами

Я не хочу писать для вас весь синтаксический анализатор, поэтому я просто пытаюсь ответить на отдельные вопросы.

• Как сделать "ни одного" или "много" [...]

Просто используйте many вместо many1.

Чтобы сделать весь блок «- Выходы -» необязательным, вы можете попробовать что-то вроде

exits <- parseExists <|> return []

• Является ли мой подход к мини-синтаксическим анализаторам правильным способом решения этой проблемы в haskell и parsec?

да. Как правило, старайтесь написать хотя бы один синтаксический анализатор для каждого типа данных, а часто и больше.

• Наконец, oneRoom в настоящее время получает строки файла, разделенные на \ n \ n, но я думаю, что могу включить это в свой синтаксический анализатор как последнюю строку синтаксического анализатора oneRoom, правильно?

Я думаю, вам не следует использовать split в функции main, а вместо этого просто используйте newline в ваших синтаксических анализаторах везде, где вы хотите иметь символ новой строки.

• В моем парсере oneRoom я в настоящее время разбираю историю как элемент, заканчивающийся на - Exit - но я не уверен, что история не потребляет следующий - Exits - или eof? Как заставить анализатор истории заканчиваться либо на первом - Exits - он находит, либо на eof (или \ n \ n, если я разбираю весь файл)

Может быть, вам нужно что-то вроде следующего:

-- succeeds if we're at the end of story
-- never consumes any input
endOfStory :: Parser ()
endOfStory = lookAhead $
  try (string "-- Room --" >> newline) <|>
  try (string "-- Exits --" >> newline) <|>
  try (newline >> newline) <|>
  eof

С такой функцией вы можете использовать manyTill ... endOfStory.

Прошу прощения за задержку с ответом. Я занимался этим в свободное время. Большое спасибо за предложения. После работы с GHCI и изменения некоторых типов данных приведенное ниже решение сработало. Я хотел опубликовать ответ здесь в надежде, что он поможет другим.

    --module Loader
-- Game parser will go here
--
import Text.ParserCombinators.Parsec
import Data.List.Split

astory = unlines ["-- Room --",
      "Cell",
      "You have been locked in a dungeon cell. The prisoner next",
      "to you whipsers, there's a tunnel behind the bed on the",
      "south wall. Good Luck!",
      "-- Exits --",
      "South: Tunnel\n"]

a_new_story = unlines [
      "You have been locked in a dungeon cell. The prisoner next",
      "to you whipsers, there's a tunnel behind the bed on the",
      "south wall. Good Luck!",
      "-- Exits --"]

type Story = String
type Destination = String
data Exit = Exit { direction :: Direction, destination :: Destination } deriving (Ord, Show, Eq)
data Exits = Exits [ Exit ] deriving (Ord, Show, Eq)
data Name = Name String deriving (Ord, Show, Eq)

data Room = Room { name  :: Name
                 , story :: String
                 , exits :: Exits
                 } deriving (Ord, Show, Eq)

data Rooms = Rooms [ Room ] deriving (Ord, Show, Eq)

data Direction = Nothing | North | South | East | West | Quit deriving (Ord, Show, Eq)

an_exit = "North: Tunnel \n"
a_full_exit = "-- Exits --\nSouth: Tunnel\n"

directionParser :: Parser Direction
directionParser =     (string "South:" >> return South)
 <|> (string "North:" >> return North)
 <|> (string "East:"  >> return East)
 <|> (string "West:"  >> return West)

parseExit :: Parser Exit
parseExit = do
    direction <- directionParser
    spaces
    destination <- many (noneOf "\n")
    newline
    return $ Exit direction destination

parseEol :: Parser ()
parseEol = do
    newline
    return $ ()

parseExits :: Parser Exits
parseExits = do
    string "-- Exits --\n"
    exits <- many parseExit
    return $ Exits exits

endOfStory :: Parser ()
endOfStory = lookAhead $
    try (string "-- Room --" >> parseEol) <|>
    try (string "-- Exits --" >> parseEol) <|>
    try (parseEol >> parseEol) <|> eof

roomname = "-- Room --\nCell\n"

parseName :: Parser Name
parseName = do
    string "-- Room --\n"
    name <- many (noneOf "\n")
    newline
    return $ Name name

oneRoom :: Parser Room
oneRoom = do
    name <- parseName
    story <- manyTill anyChar endOfStory
    exits <- parseExits <|> return (Exits [])
    newline
    return $ Room name story exits

manyRooms :: Parser Rooms
manyRooms = do
    rooms <- many oneRoom
    return $ Rooms rooms

Если вы хотите попробовать несколько комнат, обязательно добавьте новую строку между комнатами.