This is my post about tagless final encoding. There are many like it, but this one is mine. My tagless final encoding post is my best friend. It is my life. I must master it as I must master my life.
I can't think of a good intro so I modified the Rifleman's Creed. Anyway, the tagless final encoding technique has been very helpful in structuring my programs without being burdened about dependencies so much, because of this I can change dependencies and mostly don't have to re-structure my program. This technique also makes it almost effortless to do unit testing.
Just like my other posts let's do a contrived example.
This is our user story.
- A command line tool that takes a file path to a text file that contains some text.
- The content of the input file will be processed, and the text content will be capitalized.
- The processed text content will then be printed to an output file.
Let's start by creating the representation of our application.
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module AppM where
newtype AppM a
= AppM
{ runAppM :: IO a
} deriving newtype ( Functor, Applicative, Monad, MonadIO )
Then, let's define the capabilities of the app based on the made up user story. First, the cli capability.
module Capability.CLI where
class Monad m => ManageCLI m where
parseCliCommand :: m Command
interpretCLI :: Command -> m ()
data Command = Command
{ commandInput :: Text
, commandOutput :: Text
} deriving ( Eq, Show )
Next, the capabalities to manipulate files in the file system.
module Capability.File where
class Monad m => ManageFile m where
getFileContent :: Text -> m Text
printContent :: Text -> Text -> m ()
Finally, the capability to manipulate text.
module Capability.TextContent where
class Monad m => ManageTextContent m where
capitalizeContent :: Text -> m Text
With all these capabilities, I think we are ready to assemble our program. So, let's go back to the AppM module. We have to create instances but skip the implementation for now, and use undefined
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE RecordWildCards #-}
module AppM where
import Capability.CLI
import Capability.File
import Capability.TextContent
newtype AppM a
= AppM
{ runAppM :: IO a
} deriving newtype ( Functor, Applicative, Monad, MonadIO )
startApp :: IO ()
startApp = runAppM $ interpretCLI =<< parseCliCommand
instance ManageCLI AppM where
parseCliCommand :: AppM Command
parseCliCommand = undefined
interpretCLI :: Command -> AppM ()
interpretCLI Command{..} = do
file <- getFileContent commandInput
content <- capitalizeContent file
printContent commandOutput content
instance ManageFile AppM where
getFileContent :: Text -> AppM Text
getFileContent filePath = undefined
printContent :: Text -> Text -> AppM ()
printContent outputPath content = undefined
instance ManageTextContent AppM where
capitalizeContent :: Text -> AppM Text
capitalizeContent content = undefined
As you can see we were able to assemble our program in interpretCLI without any concrete implementations. When we provide the concrete implementations, we won't get so bogged down by thinking about the entire the program because we've already done that. We only have to think about the concrete implementation of individual capabilities. For example, we just need to think about how to retrieve a file, print a file, etc.
Proceeding to our concrete implementation we can pick optparse-applicative as our cli utility and relude as our prelude.
module AppM where
...
import Relude
import qualified Data.Text as T
import Options.Applicative
instance ManageCLI AppM where
parseCliCommand :: AppM Command
parseCliCommand = liftIO
$ execParser ( info ( helper <*> parseCommand ) fullDesc )
interpretCLI :: Command -> AppM ()
interpretCLI Command{..} = do
file <- getFileContent commandInput
content <- capitalizeContent file
printContent commandOutput content
instance ManageFile AppM where
getFileContent :: Text -> AppM Text
getFileContent filePath = readFileText ( T.unpack filePath )
printContent :: Text -> Text -> AppM ()
printContent outputPath content =
writeFileText ( T.unpack outputPath ) content
instance ManageTextContent AppM where
capitalizeContent :: Text -> AppM Text
capitalizeContent content = pure $ T.toUpper content
By using optparse-applicative, here's the implementation of parseCommand
parseCommand :: Parser Command
parseCommand = Command
<$> strOption ( long "input" <> short 'i' <> metavar "INPUT_FILE" <> help "Input file" )
<*> strOption ( long "output" <> short 'o' <> metavar "OUTPUT_FILE" <> help "Output file" )
One obvious downside to this is the n^2 instance problem which Vasiliy Kevroletin mentions in his article.
That's it! We import our library code to the Main module and execute the program.
module Main where
import Relude
import AppM
main :: IO ()
main = startApp
References
Purescript Halogen Realworld repository
Three Layer Cake by Matt Parson
Top comments (0)