{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE UnicodeSyntax #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DuplicateRecordFields #-}

module AronAlias where
import Control.Monad
import qualified Control.Monad.IO.Class as CM
import Control.Concurrent
import Data.Array.IO
import Data.Char 
import qualified Data.List as L
import Data.List.Split
import Data.Time
import Data.Ratio
import Data.Maybe (fromJust, isJust, fromMaybe)
import Data.Time.Clock.POSIX
import Data.Foldable (foldrM)
import Data.Typeable (typeOf) -- runtime type checker, typeOf "k"
import Data.Typeable 
import System.Directory
import System.Environment
import System.Exit
import System.FilePath.Posix
import System.IO
import System.Posix.Files
import System.Posix.Unistd
import System.Posix.Types
import System.Process
import System.Random
import Text.Read (Read)
import Text.Regex
import Text.Regex.Base
import Text.Regex.Base.RegexLike
import Text.Regex.Posix
import Text.Printf
import Debug.Trace (trace)
import Text.Pretty.Simple (pPrint)

import qualified Data.Vector         as V
import qualified Data.HashMap.Strict as M
import qualified Text.Regex.TDFA     as TD
import qualified Text.Regex          as TR
import qualified Data.Set            as DS
import qualified Data.Word           as DW 

import qualified Data.ByteString.Lazy      as BL
import qualified Data.ByteString.Lazy.Char8 as LC8 
import qualified Data.ByteString.Lazy.UTF8 as BLU
import qualified Data.ByteString.Lazy.Internal as IN (ByteString)
import qualified Data.ByteString.UTF8      as BSU
import qualified Data.ByteString           as BS
import qualified Data.Text.Lazy            as TL
import qualified Data.Text                 as TS
import qualified Data.Text.IO              as TSO
import qualified Data.Text.Encoding        as TSE
import qualified Data.Text.Lazy.Encoding   as TLE
import qualified Data.ByteString.Char8     as S8 (putStrLn, putStr, lines)   -- strict ?
import qualified Data.ByteString.Internal  as BSI (c2w) 
import qualified Data.Array as DR 
import Data.Array.IO

import Text.RawString.QQ (r)         -- Need QuasiQuotes too 

import AronModule
       
{-|
    === shorthand Write [String] to file
-}
wfs::FilePath->[String]->IO()
wfs :: FilePath -> [FilePath] -> IO ()
wfs FilePath
p [FilePath]
list = FilePath -> [FilePath] -> IO ()
writeToFile FilePath
p [FilePath]
list

wf::FilePath->String->IO()
wf :: FilePath -> FilePath -> IO ()
wf = FilePath -> FilePath -> IO ()
writeFile

sw :: Show a => a -> String
sw :: a -> FilePath
sw = a -> FilePath
forall a. Show a => a -> FilePath
show

rev :: [a] -> [a]
rev :: [a] -> [a]
rev = [a] -> [a]
forall a. [a] -> [a]
reverse
  
wfl :: FilePath -> [FilePath] -> IO ()
wfl = FilePath -> [FilePath] -> IO ()
writeFileList

rfl :: FilePath -> IO [FilePath]
rfl = FilePath -> IO [FilePath]
readFileLatin1ToList

rep :: Int -> a -> [a]
rep = Int -> a -> [a]
forall a. Int -> a -> [a]
replicate

tr :: FilePath -> FilePath
tr = FilePath -> FilePath
trim

lent :: FilePath -> Integer
lent = FilePath -> Integer
forall (t :: * -> *) b a. (Foldable t, Num b) => t a -> b
len (FilePath -> Integer)
-> (FilePath -> FilePath) -> FilePath -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> FilePath
trim

ft :: (a -> Bool) -> [a] -> [a]
ft = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter

env :: FilePath -> IO FilePath
env = FilePath -> IO FilePath
getEnv
ev :: FilePath -> IO FilePath
ev = FilePath -> IO FilePath
getEnv

cdEnv::String -> IO()
cdEnv :: FilePath -> IO ()
cdEnv FilePath
s = FilePath -> IO FilePath
getEnv FilePath
s IO FilePath -> (FilePath -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO ()
cd

cde :: FilePath -> IO ()
cde = FilePath -> IO ()
cdEnv