Enhance the user experience

Author: nigosto

lambda-parser.cabal

@@ -35,6 +35,7 @@ executable lambda-parser
         Substitution.Nameless
         Generator
         Stack
+        Interaction
 
     -- LANGUAGE extensions used by modules in this package.
     -- other-extensions:

src/Interaction.hs

@@ -0,0 +1,41 @@
+module Interaction where
+
+import Prelude hiding (lookup)
+import Generator (generateTerm, generateNamelessTerm)
+import Parser (parseTerm)
+import Stack (emptyStack)
+import Substitution.Named (substitute)
+import Transformer (toNameless, toNamed)
+import Data.Map (empty, lookup)
+import Substitution.Nameless (substituteNameless)
+
+data TermType = Nameless | Named deriving (Show, Eq)
+
+parseTermType :: String -> TermType
+parseTermType "named" = Named
+parseTermType "Named" = Named
+parseTermType "nameless" = Nameless
+parseTermType "Nameless" = Nameless
+parseTermType _ = error "Invalid term type"
+
+getOutputTermType :: IO TermType
+getOutputTermType = putStr "Please enter the type of the output terms (named, nameless): " >> parseTermType <$> getLine
+
+getSubstitutionType :: IO TermType
+getSubstitutionType = putStr "Please enter the type of the substitution to be used (named, nameless): " >> parseTermType <$> getLine
+
+doSubstituteNamed :: String -> String -> String -> String
+doSubstituteNamed term var substituteTerm = generateTerm $ substitute (parseTerm term emptyStack) (head var) (parseTerm substituteTerm emptyStack)
+
+doSubstituteNameless :: String -> String -> String -> TermType -> String
+doSubstituteNameless term var substituteTerm outputTermType =
+  let (namelessTerm, context) = toNameless (parseTerm term emptyStack) empty
+      substituteVariable = head var `lookup` context
+  in case substituteVariable of
+    Nothing -> term
+    Just index ->
+      let (substituteNamelessTerm, updatedContext) = toNameless (parseTerm substituteTerm emptyStack) context
+          result = substituteNameless namelessTerm index substituteNamelessTerm
+       in if outputTermType == Named 
+          then generateTerm $ toNamed result updatedContext
+          else generateNamelessTerm result

src/Main.hs

@@ -9,9 +9,8 @@ import System.IO (BufferMode (BlockBuffering), hSetBuffering, stdout)
 import Transformer (toNamed, toNameless)
 import Prelude hiding (lookup)
 import Stack (emptyStack)
+import Interaction (getSubstitutionType, getOutputTermType, doSubstituteNameless, TermType (Named), doSubstituteNamed)
 
--- TODO: let the user decide which substitution to be used and how the
---       result should be displayed - either as named or nameless term
 main :: IO ()
 main = do
   hSetBuffering stdout $ BlockBuffering $ Just 1
@@ -20,15 +19,10 @@ main = do
   if length var /= 1
     then error "please provide valid variable"
     else do
-      let (namelessTerm, context) = toNameless (parseTerm term emptyStack) empty
-          substituteVariable = head var `lookup` context
       substituteTerm <- putStr "Input substitution term: " >> getLine
-      case substituteVariable of
-        Nothing -> putStrLn term
-        Just index ->
-          let (substituteNamelessTerm, updatedContext) = toNameless (parseTerm substituteTerm emptyStack) context
-           in putStrLn $ generateTerm $ toNamed (substituteNameless namelessTerm index substituteNamelessTerm) updatedContext
-
--- let substituteVariable = head var
--- substituteTerm <- putStr "Input substitution term: " >> getLine
--- putStrLn $ generateTerm $ substitute (parseTerm term) substituteVariable (parseTerm substituteTerm)
+      substitutionType <- getSubstitutionType
+      if substitutionType == Named
+      then putStrLn $ doSubstituteNamed term var substituteTerm
+      else do
+        outputFormat <- getOutputTermType
+        putStrLn $ doSubstituteNameless term var substituteTerm outputFormat