some ability to use JAC_PATH &c.

cli args

app/Main.hs

@@ -9,9 +9,9 @@ import           Options.Applicative
 import qualified Paths_jacinda        as P
 import           System.IO            (stdin)
 
-data Command = TypeCheck !FilePath
-             | Run !FilePath !(Maybe FilePath)
-             | Expr !BSL.ByteString !(Maybe FilePath) !(Maybe BS.ByteString)
+data Command = TypeCheck !FilePath ![FilePath]
+             | Run !FilePath !(Maybe FilePath) ![FilePath]
+             | Expr !BSL.ByteString !(Maybe FilePath) !(Maybe BS.ByteString) ![FilePath]
              | Eval !BSL.ByteString
 
 jacFile :: Parser FilePath
@@ -47,11 +47,22 @@ commandP = hsubparser
     <> command "run" (info runP (progDesc "Run from file")))
     <|> exprP
     where
-        tcP = TypeCheck <$> jacFile
-        runP = Run <$> jacFile <*> inpFile
-        exprP = Expr <$> jacExpr <*> inpFile <*> jacFs
+        tcP = TypeCheck <$> jacFile <*> includes
+        runP = Run <$> jacFile <*> inpFile <*> includes
+        exprP = Expr <$> jacExpr <*> inpFile <*> jacFs <*> includes
         eP = Eval <$> jacExpr
 
+includes :: Parser [FilePath]
+includes = many $ strOption
+    (metavar "DIR"
+    <> long "include"
+    <> short 'I'
+    <> dirCompletions)
+
+dirCompletions :: HasCompleter f => Mod f a
+dirCompletions = completer . bashCompleter $ "directory"
+
+
 wrapper :: ParserInfo Command
 wrapper = info (helper <*> versionMod <*> commandP)
     (fullDesc
@@ -65,9 +76,9 @@ main :: IO ()
 main = run =<< execParser wrapper
 
 run :: Command -> IO ()
-run (TypeCheck fp)         = tcIO =<< BSL.readFile fp
-run (Run fp Nothing)       = do { contents <- BSL.readFile fp ; runOnHandle contents Nothing stdin }
-run (Run fp (Just dat))    = do { contents <- BSL.readFile fp ; runOnFile contents Nothing dat }
-run (Expr eb Nothing fs)   = runOnHandle eb fs stdin
-run (Expr eb (Just fp) fs) = runOnFile eb fs fp
-run (Eval e)               = print (exprEval e)
+run (TypeCheck fp is)         = tcIO is =<< BSL.readFile fp
+run (Run fp Nothing is)       = do { contents <- BSL.readFile fp ; runOnHandle is contents Nothing stdin }
+run (Run fp (Just dat) is)    = do { contents <- BSL.readFile fp ; runOnFile is contents Nothing dat }
+run (Expr eb Nothing fs is)   = runOnHandle is eb fs stdin
+run (Expr eb (Just fp) fs is) = runOnFile is eb fs fp
+run (Eval e)                  = print (exprEval e)

bench/Bench.hs

@@ -9,7 +9,7 @@ import           Jacinda.File
 
 main :: IO ()
 main =
-    defaultMain [ bgroup "exprEval"
+    defaultMain [ bgroup "eval"
                       [ bench "exprEval" $ nf exprEval "[x+' '+y]|'' split '01-23-1987' /-/"
                       ]
                 ]

jacinda.cabal

@@ -18,6 +18,9 @@ extra-source-files:
     man/ja.1
     doc/guide.pdf
     test/examples/*.jac
+    examples/*.jac
+
+data-files:
     lib/*.jac
     prelude/*.jac
 
@@ -49,9 +52,11 @@ library jacinda-lib
         Jacinda.Backend.Normalize
         Jacinda.Backend.TreeWalk
         Jacinda.Backend.Printf
-        Jacinda.Env
+        Jacinda.Include
         Data.List.Ext
         Data.Vector.Ext
+        Paths_jacinda
+    autogen-modules:  Paths_jacinda
 
     default-language: Haskell2010
     ghc-options:      -Wall -O2
@@ -66,6 +71,8 @@ library jacinda-lib
         transformers,
         regex-rure >=0.1.2.0,
         microlens,
+        directory,
+        filepath,
         microlens-mtl,
         vector,
         recursion >=1.0.0.0,

man/MANPAGE.md

@@ -35,6 +35,9 @@ ja - Jacinda: data filtering, processing, reporting
 **-V** **-\-version**
 :   Display version information
 
+**-I** **-\-include**
+:   Include directory for imports
+
 # LANGUAGE
 
 ## REGEX

man/ja.1

@@ -31,6 +31,9 @@ Display help
 .TP
 \f[B]-V\f[R] \f[B]--version\f[R]
 Display version information
+.TP
+\f[B]-I\f[R] \f[B]--include\f[R]
+Include directory for imports
 .SH LANGUAGE
 .SS REGEX
 .PP

src/Jacinda/File.hs

@@ -1,5 +1,4 @@
-module Jacinda.File ( tyCheck
-                    , tcIO
+module Jacinda.File ( tcIO
                     , tySrc
                     , runOnHandle
                     , runOnFile
@@ -21,6 +20,7 @@ import           Data.Tuple                 (swap)
 import           Jacinda.AST
 import           Jacinda.Backend.Normalize
 import           Jacinda.Backend.TreeWalk
+import           Jacinda.Include
 import           Jacinda.Lexer
 import           Jacinda.Parser
 import           Jacinda.Parser.Rewrite
@@ -30,28 +30,28 @@ import           Jacinda.Ty
 import           Regex.Rure                 (RurePtr)
 import           System.IO                  (Handle)
 
-parseLib :: FilePath -> StateT AlexUserState IO [D AlexPosn]
-parseLib fp = do
-    contents <- liftIO $ BSL.readFile fp
+parseLib :: [FilePath] -> FilePath -> StateT AlexUserState IO [D AlexPosn]
+parseLib incls fp = do
+    contents <- liftIO $ BSL.readFile =<< resolveImport incls fp
     st <- get
     case parseLibWithCtx contents st of
         Left err              -> liftIO (throwIO err)
         Right (st', ([], ds)) -> put st' $> (rewriteD <$> ds)
-        Right (st', (is, ds)) -> do { put st' ; dss <- traverse parseLib is ; pure (concat dss ++ ds) }
+        Right (st', (is, ds)) -> do { put st' ; dss <- traverse (parseLib incls) is ; pure (concat dss ++ ds) }
 
-parseE :: BSL.ByteString -> StateT AlexUserState IO (Program AlexPosn)
-parseE bs = do
+parseE :: [FilePath] -> BSL.ByteString -> StateT AlexUserState IO (Program AlexPosn)
+parseE incls bs = do
     st <- get
     case parseWithCtx bs st of
         Left err -> liftIO $ throwIO err
         Right (st', (is, Program ds e)) -> do
             put st'
-            dss <- traverse parseLib is
+            dss <- traverse (parseLib incls) is
             pure $ Program (concat dss ++ fmap rewriteD ds) (rewriteE e)
 
 -- | Parse + rename (decls)
-parseEWithMax :: BSL.ByteString -> IO (Program AlexPosn, Int)
-parseEWithMax bsl = uncurry renamePGlobal . swap . second fst3 <$> runStateT (parseE bsl) alexInitUserState
+parseEWithMax :: [FilePath] -> BSL.ByteString -> IO (Program AlexPosn, Int)
+parseEWithMax incls bsl = uncurry renamePGlobal . swap . second fst3 <$> runStateT (parseE incls bsl) alexInitUserState
     where fst3 (x, _, _) = x
 
 -- | Parse + rename (globally)
@@ -70,39 +70,39 @@ compileFS :: Maybe BS.ByteString -> RurePtr
 compileFS (Just bs) = compileDefault bs
 compileFS Nothing   = defaultRurePtr
 
-runOnBytes :: FilePath
+runOnBytes :: [FilePath]
+           -> FilePath -- ^ Data file name, for @nf@
            -> BSL.ByteString -- ^ Program
            -> Maybe BS.ByteString -- ^ Field separator
            -> BSL.ByteString
            -> IO ()
-runOnBytes fp src cliFS contents = do
-    (ast, m) <- parseEWithMax src
+runOnBytes incls fp src cliFS contents = do
+    incls' <- defaultIncludes <*> pure incls
+    (ast, m) <- parseEWithMax incls' src
     (typed, i) <- yeetIO $ runTypeM m (tyProgram ast)
     cont <- yeetIO $ runJac (ASCII.pack fp) (compileFS (cliFS <|> getFS ast)) i typed
     cont $ fmap BSL.toStrict (ASCIIL.lines contents)
     -- see: BSL.split, BSL.splitWith
 
-runOnHandle :: BSL.ByteString -- ^ Program
+runOnHandle :: [FilePath]
+            -> BSL.ByteString -- ^ Program
             -> Maybe BS.ByteString -- ^ Field separator
             -> Handle
             -> IO ()
-runOnHandle src cliFS = runOnBytes "(runOnBytes)" src cliFS <=< BSL.hGetContents
+runOnHandle is src cliFS = runOnBytes is "(runOnBytes)" src cliFS <=< BSL.hGetContents
 
-runOnFile :: BSL.ByteString
+runOnFile :: [FilePath]
+          -> BSL.ByteString
           -> Maybe BS.ByteString
           -> FilePath
           -> IO ()
-runOnFile e fs fp = runOnBytes fp e fs =<< BSL.readFile fp
+runOnFile is e fs fp = runOnBytes is fp e fs =<< BSL.readFile fp
 
-tcIO :: BSL.ByteString -> IO ()
-tcIO = yeetIO . tyCheck
-
--- | Typecheck an expression
-tyCheck :: BSL.ByteString -> Either (Error AlexPosn) ()
-tyCheck src =
-    case parseWithMax' src of
-        Right (ast, m) -> void $ runTypeM m (tyProgram ast)
-        Left err       -> throw err
+tcIO :: [FilePath] -> BSL.ByteString -> IO ()
+tcIO incls src = do
+    incls' <- defaultIncludes <*> pure incls
+    (ast, m) <- parseEWithMax incls' src
+    yeetIO $ void $ runTypeM m (tyProgram ast)
 
 tySrc :: BSL.ByteString -> T K
 tySrc src =

src/Jacinda/Include.hs

@@ -0,0 +1,36 @@
+module Jacinda.Include ( defaultIncludes
+                       , resolveImport
+                       ) where
+
+import           Control.Exception  (Exception, throwIO)
+import           Control.Monad      (filterM)
+import           Data.List.Split    (splitWhen)
+import           Data.Maybe         (listToMaybe)
+import           Paths_jacinda      (getDataDir)
+import           System.Directory   (doesFileExist)
+import           System.Environment (lookupEnv)
+import           System.FilePath    ((</>))
+
+data ImportError = FileNotFound !FilePath ![FilePath] deriving (Show)
+
+instance Exception ImportError where
+
+defaultIncludes :: IO ([FilePath] -> [FilePath])
+defaultIncludes = do
+    path <- jacPath
+    d <- getDataDir
+    pure $ (d:) . (++path)
+
+-- | Parsed @JAC_PATH@
+jacPath :: IO [FilePath]
+jacPath = maybe [] splitEnv <$> lookupEnv "JAC_PATH"
+
+splitEnv :: String -> [FilePath]
+splitEnv = splitWhen (== ':')
+
+resolveImport :: [FilePath] -- ^ Places to look
+              -> FilePath
+              -> IO FilePath
+resolveImport incl fp =
+    maybe (throwIO $ FileNotFound fp incl) pure . listToMaybe
+        =<< (filterM doesFileExist . fmap (</> fp) $ incl)

test/Spec.hs

@@ -85,7 +85,7 @@ sumBytesAST =
             (IParseCol () 5)
 
 tyFile :: FilePath -> Assertion
-tyFile = tcIO <=< BSL.readFile
+tyFile = tcIO [] <=< BSL.readFile
 
 tyOfT :: BSL.ByteString -> T K -> Assertion
 tyOfT src expected =