haskell - matematico - Cómo escribir reglas de construcción de punto fijo en Shake, por ejemplo, látex

exponencial en latex

Question

Usando la biblioteca de compilación Shake Haskell, ¿cómo puedo escribir una regla usando un programa que necesita alcanzar un punto fijo? Imagina que tengo un programa foo que toma una input archivo y produce un archivo de salida, que debería haber aplicado foo repetidamente hasta que el archivo de salida no cambie. ¿Cómo puedo escribir eso en Shake?

El ejemplo típico de este patrón es LaTeX.

Answer 1

Ampliando la de , a continuación hay un código de ejemplo de foo_transitive . Dicho esto, para este caso en particular, solo usaría latexmk que hace lo correcto ™.

import Control.Monad.Fix (fix, mfix)
import Control.Monad.IO.Class (MonadIO(liftIO))
import Text.Printf (printf)

type SHA = Int

data TeXCompilationStage 
  = Init
  | BibTeX
  | Recompile SHA
  deriving (Show, Eq)

data TeXResult
  = Stable SHA
  | Unstable
  deriving (Show, Eq)

f retry x budgetLaTeXCalls
  | budgetLaTeXCalls <= 0
      = do
          liftIO $ putStrLn "Budget for LaTeX depleted; result didn''t converge"
          return Unstable
  | otherwise
      = case x of
          Init        -> do
            liftIO $ do 
              putStrLn "Init"
              putStrLn "  # latex"
            retry BibTeX (budgetLaTeXCalls-1)
          BibTeX      -> do
            liftIO $ do
              putStrLn "BibTeX"
              putStrLn "  # bibtex"
            retry (Recompile 0) budgetLaTeXCalls
          Recompile previousSHA -> do
            let budgetLaTeXCalls'' = budgetLaTeXCalls - 1
                calculcatedSHA    = 3
            liftIO $ do
              printf "Recompile (budget: %d)/n" budgetLaTeXCalls
              printf "  Prevous SHA:%d/n  Current SHA:%d/n" previousSHA calculcatedSHA
            if calculcatedSHA == previousSHA
              then do
                liftIO $ putStrLn "  Stabilized"
                return $ Stable calculcatedSHA
              else do
                liftIO $ putStrLn "  Unstable"
                retry (Recompile (previousSHA+1)) (budgetLaTeXCalls-1)

latex :: Int -> IO TeXResult
latex = fix f Init

Answer 2

En primer lugar, tenga en cuenta que llamar a Latex repetidamente no siempre produce un punto fijo, así que asegúrese de tener un límite en las iteraciones. Además, algunas distribuciones (MikTex) proporcionan versiones de Latex que se ejecutan automáticamente tantas veces como sea necesario, por lo que si las usa, el problema desaparece.

Escribe tu propio comando foo_transitive

La forma más fácil de resolver el problema, suponiendo que cada ejecución de foo tenga las mismas dependencias, es resolver el problema fuera del sistema de compilación. Simplemente escriba un comando foo_transitive , ya sea como un script de shell o como una función de Haskell, que cuando se suministra un archivo de entrada produce un archivo de salida ejecutándose repetidamente y verificando si ha alcanzado un punto fijo. El sistema de compilación ahora puede usar foo_transitive y no hay problemas con las dependencias.

Codificarlo en el sistema de compilación.

Necesita escribir dos reglas, una que da un paso y otra que determina qué paso es el correcto de usar:

let step i = "tempfile" <.> show i

"tempfile.*" *> /out -> do
    let i = read $ takeExtension out :: Int
    if i == 0 then
        copyFile "input" out
    else
        let prev = step (i-1)
        need [prev]
        -- perhaps require addition dependencies, depending on prev
        system'' "foo" [prev,out]

"output" *> /out -> do
    let f i = do
            old <- readFile'' $ step (i-1)
            new <- readFile'' $ step i
            if old == new || i > 100 then copyFile (step i) out else f (i+1)
    f 1

La primera regla genera tempfile.2 desde tempfile.1 y así sucesivamente, por lo que podemos need ["tempfile.100"] para obtener la iteración número 100. Si las dependencias cambian en cada paso, podemos ver el resultado anterior para calcular las nuevas dependencias.

La segunda regla recorre todos los pares de valores en la secuencia y se detiene cuando son iguales. Si está implementando esto en un sistema de compilación de producción, es posible que desee evitar llamar a readFile'' en cada elemento dos veces (una vez como i-1 y una vez como i ).