Implemented backend generators as instances of a class

Author: leopiney

app/Main.hs

@@ -7,8 +7,15 @@ import           TensorSafe.Commands.Check    (check)
 import           TensorSafe.Commands.Compile  (compile)
 import           TensorSafe.Commands.Examples (examples)
 
+data Backend = JavaScript | Python deriving (Data,Typeable,Show,Eq)
+
 data TensorSafe = Check   { path :: FilePath }
-                | Compile { path :: FilePath, module_name :: String }
+                | Compile {
+                    path        :: FilePath,
+                    module_name :: String,
+                    backend     :: Backend,
+                    out         :: Maybe FilePath
+                  }
                 | Examples
                 deriving (Data, Typeable, Show, Eq)
 
@@ -21,6 +28,10 @@ cCompile :: TensorSafe
 cCompile = Compile
     { path = def &= typ "PATH" &= help "Path to Haskell module with TensorSafe model inside"
     , module_name = def &= help "The module name inside the TensorSafe model file"
+    , backend = enum
+        [ JavaScript &= help "Compile to JavaScript backend"
+        , Python     &= help "Compile to Python backend"]
+    , out = def &= help "If specified, the output file path to which the network will be generated"
     } &= help "Compiles module and outputs Neural Network model for the specified backend"
 
 cExamples :: TensorSafe
@@ -34,6 +45,6 @@ main = do
     -- print =<< tensorSafe
     r <- tensorSafe
     case r of
-        Check { path = p }                    -> check p
-        Compile { path = p, module_name = m } -> compile p m
-        Examples                              -> examples
+        Check { path = p }                                           -> check p
+        Compile { path = p, module_name = m, backend = b, out = o }  -> compile p m (show b) o
+        Examples                                                     -> examples

src/TensorSafe.hs

@@ -1,14 +1,14 @@
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 module TensorSafe (
-    Backend (..),
-    evalCNetwork,
+    JavaScript (..),
+    generate,
     INetwork,
     MkINetwork,
     mkINetwork,
     toCNetwork
 ) where
 
-import           TensorSafe.Compile.Expr (Backend (..), evalCNetwork)
+import           TensorSafe.Compile.Expr (JavaScript (..), generate)
 import           TensorSafe.Network      (INetwork, MkINetwork, mkINetwork,
                                           toCNetwork)

src/TensorSafe/Commands/Compile.hs

@@ -6,21 +6,26 @@ import           System.Exit
 import           TensorSafe.Commands.Utils
 
 
-compile :: String -> String -> IO ()
-compile path moduleName = do
-    r <- runInterpreter $ checkAndCompile path moduleName
+compile :: String -> String -> String -> Maybe FilePath -> IO ()
+compile path moduleName backend out = do
+    r <- runInterpreter $ checkAndCompile path moduleName backend out
     case r of
         Left err -> do
             putStrLn $ errorString err
             exitWith $ ExitFailure 1
         Right () -> do
             exitWith $ ExitSuccess
 
-checkAndCompile :: String -> String -> Interpreter ()
-checkAndCompile path moduleName = do
+checkAndCompile :: String -> String -> String -> Maybe FilePath -> Interpreter ()
+checkAndCompile path moduleName backend out = do
     loadModules [path]
     setTopLevelModules [moduleName]
     setImportsQ [("TensorSafe", Nothing), ("Data.Text.Lazy", Nothing)]
 
-    r <- interpret "unpack $ evalCNetwork JavaScript (toCNetwork nn)" (as :: String)
-    liftIO $ putStrLn r
+    case out of
+        Nothing -> do
+            r <- interpret ("unpack $ generate " ++ backend ++ " (toCNetwork nn)") (as :: String)
+            liftIO $ putStrLn r
+        Just f -> do
+            r <- interpret ("unpack $ generate " ++ backend ++ " (toCNetwork nn)") (as :: String)
+            liftIO $ writeFile f r

src/TensorSafe/Compile/Expr.hs

@@ -13,28 +13,25 @@ data CNetwork = CNSequence CNetwork
               | CNNil
               deriving Show
 
--- TODO
--- Use generate instead of eval
--- Use classes and instanciate for each language.
--- ie: class Generate l where
-    --     generate :: l -> CN -> Text
-data Backend = JavaScript | Python deriving Show
-
-evalCNetwork :: Backend -> CNetwork -> Text
-evalCNetwork Python cn     = T.intercalate "\n" (evalPython cn)
-evalCNetwork JavaScript cn = T.intercalate "\n" (evalJS cn)
-
-
-evalPython :: CNetwork -> [Text]
-evalPython = undefined
-
-evalJS :: CNetwork -> [Text]
-evalJS (CNSequence cn)  = ["const model = tf.sequential();"] ++ evalJS cn
-evalJS (CNCons cn1 cn2) = (evalJS cn1) ++ (evalJS cn2)
-evalJS (CNNil) = []
-evalJS CNReturn = [] -- ["return model"]
-evalJS (CNLayer layer params) =
-    [format ("model.add(tf.layers." % string % "(" % string % "))") layer (paramsToJS params)]
+
+data JavaScript = JavaScript deriving Show
+
+-- | Class that defines which languages are supported for CNetworks generation to text
+class Generator l where
+    generate :: l -> CNetwork -> Text
+
+-- | Instance for JavaScript generation
+instance Generator JavaScript where
+    generate _ =
+        T.intercalate "\n" . evalJS
+        where
+            evalJS :: CNetwork -> [Text]
+            evalJS (CNSequence cn)  = ["const model = tf.sequential();"] ++ evalJS cn
+            evalJS (CNCons cn1 cn2) = (evalJS cn1) ++ (evalJS cn2)
+            evalJS (CNNil) = []
+            evalJS CNReturn = [] -- ["return model"]
+            evalJS (CNLayer layer params) =
+                [format ("model.add(tf.layers." % string % "(" % string % "))") layer (paramsToJS params)]
 
 
 paramsToJS :: Map String String -> String

src/TensorSafe/Examples/Examples.hs

@@ -5,7 +5,7 @@ module TensorSafe.Examples.Examples where
 import           Data.Maybe                        (Maybe, fromJust)
 import           Data.Text.Lazy                    (unpack)
 
-import           TensorSafe.Compile.Expr           (Backend (..), evalCNetwork)
+import           TensorSafe.Compile.Expr           (JavaScript (..), generate)
 import           TensorSafe.Examples.MnistExample  (mnist, mnistDense)
 import           TensorSafe.Examples.SimpleExample (myNet)
 import           TensorSafe.Generic.Shape
@@ -84,7 +84,7 @@ mnistExample =
         putStrLn $ "\n"
         putStrLn $ "MNIST generation"
         putStrLn $ "-------------"
-        putStrLn $ unpack $ evalCNetwork JavaScript (toCNetwork mnist)
+        putStrLn $ unpack $ generate JavaScript (toCNetwork mnist)
 
 mnistExampleDense :: IO ()
 mnistExampleDense =
@@ -99,5 +99,5 @@ mnistExampleDense =
         putStrLn $ "\n"
         putStrLn $ "MNIST generation"
         putStrLn $ "-------------"
-        putStrLn $ unpack $ evalCNetwork JavaScript (toCNetwork mnistDense)
+        putStrLn $ unpack $ generate JavaScript (toCNetwork mnistDense)