Uso del analizador de diseño de Trifecta

Question

Estoy experimentando con Trifecta para analizar un lenguaje funcional muy simple con una sintaxis de diseño similar a Haskell. Estoy trabajando en los documentos de Haddock y en mi experiencia con Parsec, porque no pude encontrar ningún material introductorio en Trifecta.

El problema que tengo es con el uso de elementos de diseño, ya que ni siquiera los documentos de Haddock ayudan mucho.

Dado el siguiente código:

import Text.Trifecta 
import Text.Trifecta.Parser.Token.Style 
import Text.Trifecta.Parser.Identifier.Style 
import Text.Trifecta.Layout.Combinators 
import Text.Trifecta.Language.Prim 

import Control.Applicative 
import Control.Monad.Trans 
import Data.Maybe (fromMaybe) 

import Data.HashSet as HashSet 
import Data.ByteString.UTF8 as UTF8 

-- Copypasta from Text.Trifecta.Parser.Identifier.Style 
set :: [String] -> HashSet ByteString 
set = HashSet.fromList . fmap UTF8.fromString 

lang :: MonadParser m => LanguageDef m 
lang = LanguageDef{ languageCommentStyle = haskellCommentStyle 
        , languageIdentifierStyle = emptyIdents{ styleReserved = set keywords } 
        , languageOperatorStyle = emptyOps{ styleReserved = set ops } 
        } 
    where 
    keywords = ["where"] 
    ops = ["="] 

data Def = Def ByteString [ByteString] [ByteString] [Def] 
     deriving Show 

instance MonadLanguage m => MonadLanguage (Layout m) where 
    askLanguage = fmap liftLanguageDef $ lift askLanguage 

def :: (MonadParser m) => Layout (Language m) Def 
def = Def <$> identifier <*> vars <* reservedOp "=" <*> vars <*> laidout locals 
    where 
    vars = many identifier 
    locals = fromMaybe [] <$> optional (reserved "where" *> defs) 

defs :: (MonadParser m) => Layout (Language m) [Def] 
defs = laidout (many def) 

test :: String -> IO() 
test = parseTest $ run $ defs <* eof 
    where 
    run p = runLanguage (fst <$> runLayout p defaultLayoutState) lang 

Estoy tratando de analizar el siguiente texto con test:

f x = x y a b c -- 1 
    where   -- 2 
    y = d  -- 3 
g x = z   -- 4 

pero falla con este error de análisis:

(interactive):4:2: error: expected: "=", 
    identifier, letter or digit 
g x = z   -- 4 
^  

pero si comento las líneas 2 y 3, funciona.

Entonces, ¿cómo hago para analizar incluso cuando se incluyen las líneas 2 y 3?

Answer 1

Hay un par de errores en el soporte Layout para Trifecta. Necesito portar algunas correcciones desde la implementación de Scala.

Cabe destacar que algunas cosas deben deshabilitar el inicio de la verificación de línea que no, por lo que se intentó hacer una inserción automática de punto y coma donde se obtiene el error.

Lo porté desde otra base de código que hacía suposiciones ligeramente diferentes y ofrecía invariantes ligeramente diferentes de las que hace trifecta.

Esto es en realidad una gran parte de por qué no se encuentra actualmente en la rama principal en github.

Arreglo para usar la nueva API basada en parsers, y portar esos cambios es la última cosa importante que debo hacer antes de poder enviar 0.90.

Mientras tanto, no confiaría en ello. Mis disculpas.

Actualizaré esta respuesta tan pronto como sea estable.