Haskell+Nix+BNFC, One Package

.gitignore

/dist/
/dist-*/
/result
/result-*
/app/Example
cabal.project.local
Setup

README.org

Fixup (work around gist limitations)

mkdir app ; git mv app{_slash_,/}Main.hs ; git mv app{_slash_,/}Example.cf ; git mv app{_slash_,/}lex-fixes.patch

Commands

Clean full build

nix-build

Dev mode

nix-shell

Then you can build with cabal v1-build with or without --nix=True (or $HOME/.cabal/config containing nix: True).

app_slash_Example.cf

--- top level

entrypoints Example;

Example . Example ::= Ident;

app_slash_lex-fixes.patch

diff --git a/app/Example/Lex.x~ b/app/Example/Lex.x
index d17d052..2d37f97 100644
--- a/app/Example/Lex.x~
+++ b/app/Example/Lex.x
@@ -35,21 +35,21 @@ $u = [. \n]          -- universal: any character
 
 -- Whitespace (skipped)
 $white+ ;
 
 -- Symbols
 @rsyms
     { tok (eitherResIdent TV) }
 
 -- token Name
 \' ([$u # [\' \\]] | \\ [\' \\ f n r t]) * \'
-    { tok (eitherResIdent T_Name) }
+    { tok (T_Name . unescapeInitTail) }
 
 -- Keywords and Ident
 $l $i*
     { tok (eitherResIdent TV) }
 
 -- String
 \" ([$u # [\" \\ \n]] | (\\ (\" | \\ | \' | n | t | r | f)))* \"
     { tok (TL . unescapeInitTail) }
 
 -- Integer
@@ -179,20 +179,21 @@ resWords =
 unescapeInitTail :: Data.Text.Text -> Data.Text.Text
 unescapeInitTail = Data.Text.pack . unesc . tail . Data.Text.unpack
   where
   unesc s = case s of
     '\\':c:cs | elem c ['\"', '\\', '\''] -> c : unesc cs
     '\\':'n':cs  -> '\n' : unesc cs
     '\\':'t':cs  -> '\t' : unesc cs
     '\\':'r':cs  -> '\r' : unesc cs
     '\\':'f':cs  -> '\f' : unesc cs
     '"':[]       -> []
+    '\'':[]      -> []
     c:cs         -> c : unesc cs
     _            -> []
 
 -------------------------------------------------------------------
 -- Alex wrapper code.
 -- A modified "posn" wrapper.
 -------------------------------------------------------------------
 
 data Posn = Pn !Int !Int !Int
   deriving (Eq, Show, Ord)

app_slash_Main.hs

-- Program to test parser, automatically generated by BNF Converter.

module Main where

import Prelude
  ( ($)
  , Either(..)
  , Int, (>)
  , String, (++), unlines
  , Show, show
  , IO, (>>), (>>=), mapM_, putStrLn
  , FilePath
  )
import Data.Text.IO   ( getContents, readFile )
import qualified Data.Text
import System.Environment ( getArgs )
import System.Exit        ( exitFailure, exitSuccess )
import Control.Monad      ( when )

import Example.Abs   ()
import Example.Lex   ( Token )
import Example.Par   ( pExample, myLexer )
import Example.Print ( Print, printTree )

type Err        = Either String
type ParseFun a = [Token] -> Err a
type Verbosity  = Int

putStrV :: Verbosity -> String -> IO ()
putStrV v s = when (v > 1) $ putStrLn s

runFile :: (Print a, Show a) => Verbosity -> ParseFun a -> FilePath -> IO ()
runFile v p f = putStrLn f >> readFile f >>= run v p

run :: (Print a, Show a) => Verbosity -> ParseFun a -> Data.Text.Text -> IO ()
run v p s =
  case p ts of
    Left err -> do
      putStrLn "\nParse              Failed...\n"
      putStrV v "Tokens:"
      putStrV v $ show ts
      putStrLn err
      exitFailure
    Right tree -> do
      putStrLn "\nParse Successful!"
      showTree v tree
      exitSuccess
  where
  ts = myLexer s

showTree :: (Show a, Print a) => Int -> a -> IO ()
showTree v tree = do
  putStrV v $ "\n[Abstract Syntax]\n\n" ++ show tree
  putStrV v $ "\n[Linearized tree]\n\n" ++ printTree tree

usage :: IO ()
usage = do
  putStrLn $ unlines
    [ "usage: Call with one of the following argument combinations:"
    , "  --help          Display this help message."
    , "  (no arguments)  Parse stdin verbosely."
    , "  (files)         Parse content of files verbosely."
    , "  -s (files)      Silent mode. Parse content of files silently."
    ]
  exitFailure

main :: IO ()
main = do
  args <- getArgs
  case args of
    ["--help"] -> usage
    []         -> getContents >>= run 2 pExample
    "-s":fs    -> mapM_ (runFile 0 pExample) fs
    fs         -> mapM_ (runFile 2 pExample) fs

default.nix

{ pkgs ? import <nixpkgs> {} }:
let
  src = builtins.fetchGit {
     url = ./.;
  };
in pkgs.haskellPackages.callCabal2nix "" src {}

example.cabal

cabal-version:      3.0
name:               example
version:            0.1.0.0

build-type:         Custom

custom-setup
    setup-depends:
          Cabal
        , base
        , process
        --, BNFC

-- This could be split up into lib or src folder and app folder,
-- a library with most of the code and an executable that exposes it as a CLI,
-- as many projects prefer. Here, it has been kept simplistic/minimal.
executable example
    main-is:          Main.hs

    other-modules:
        Example.Par
        Example.Lex
        Example.Abs
        Example.Print

    autogen-modules:
        Example.Par
        Example.Lex
        Example.Abs
        Example.Print

    build-depends:
          base
        , text
        , array
    hs-source-dirs:   app
    default-language: Haskell2010

    build-tool-depends:
        BNFC:bnfc,
        -- ^ needed for Nix even though it should probably be supplied through custom-setup:setup-depends
        alex:alex,
        happy:happy

Setup.hs

import Distribution.Simple (defaultMainWithHooks, simpleUserHooks, confHook, cleanHook)
import System.Process (callProcess)


main = defaultMainWithHooks simpleUserHooks
  { confHook = interceptConf
  , cleanHook = interceptClean
  }


interceptConf (pkg, info) flags = do
  callProcess "bnfc" ["-o", "app", "-d", "--text-token", "--functor", "app/Example.cf" ]

  callProcess "rm" [ "app/Example/" <> file <> ".hs" | file <- ["Skel", "ErrM", "Test"] ]

  -- Do any needed patching here.
  --callProcess "patch" [ "app/Example/Lex.x", "app/lex-fixes.patch" ]

  confHook simpleUserHooks (pkg, info) flags


interceptClean pkg () hooks flags = do
  callProcess "rm" [ "-r", "app/Example/" ]

  cleanHook simpleUserHooks pkg () hooks flags

shell.nix

{ pkgs ? import <nixpkgs> {} }:
(pkgs.haskell.lib.addBuildTool
  (import ./. { inherit pkgs; })
  pkgs.cabal-install
).env