Hydra Framework

An all-in-one framework for writing Haskell apps which use the following features out of the box:

• Multithreading
• Safe STM-powered concurrency
• KV DB functionality (Redis & RocksDB backends supported)
• SQL DB functionality (beam incorporated, SQLite supported, PG & MySQL possible)
• Logging
• Random data generation
• Many others

With the framework, you can create complex applications that have a good maintainability, testability, simplicity, that have a good structure and are easy to read and change. The key principles in the framework:

• Layered architecture
• Separation of Subsystem Interfaces, Business Logic, Runtime and Implementation
• Convenient and simple to use eDSLs for Business Logic
• Layered structure of business application: State, Domain, Business Logic

The Hydra Project

This project demonstrates the principles of Software Design and Architecture in pure Functional Programming. It provides a framework implemented with several different approaches for easy comparison:

• Final Tagless
• Free Monad
• Church Encoded Free Monad

The project is a showcase for my book Functional Design and Architecture. The approaches presented in Hydra are well-described and rationalized in the book, so you may obtain even more info about best practices and ideas of how to write a good Haskell code.

Sample applications

There are 3 sample applications:

• Astro app: web server (with servant) and CLI client tool which allows to track meteors (tool for astronomers).
• PerfTestApp: an application you can run to measure the performance of the three engines.
• MeteorCounter: application which demonstrates the usage of STM and multithreading using three engines.

Sample SQL-related code

createMeteor :: MeteorTemplate -> D.SqlConn BS.SqliteM -> L.AppL MeteorId
createMeteor mtp@(MeteorTemplate {..}) conn = do
  L.logInfo $ "Inserting meteor into SQL DB: " <> show mtp

  let time = Time.UTCTime (toEnum 1) (Time.secondsToDiffTime 0)

  doOrFail
    $ L.scenario
    $ L.runDB conn
    $ L.insertRows
    $ B.insert (SqlDB._meteors SqlDB.astroDb)
    $ B.insertExpressions
          [ SqlDB.Meteor B.default_
            (B.val_ size)
            (B.val_ mass)
            (B.val_ azimuth)
            (B.val_ altitude)
            (B.val_ time)
          ]

  let predicate meteorDB
          = (SqlDB._meteorSize meteorDB     ==. B.val_ size)
        &&. (SqlDB._meteorMass meteorDB     ==. B.val_ mass)
        &&. (SqlDB._meteorAzimuth meteorDB  ==. B.val_ azimuth)
        &&. (SqlDB._meteorAltitude meteorDB ==. B.val_ altitude)

  m <- doOrFail
    $ L.scenario
    $ L.runDB conn
    $ L.findRow
    $ B.select
    $ B.limit_ 1
    $ B.filter_ predicate
    $ B.all_ (SqlDB._meteors SqlDB.astroDb)
  pure $ SqlDB._meteorId $ fromJust m

Additional materials describing these ideas:

• Hierarchical Free Monads and Software Design in Functional Programming (Talk, Eng) | Slides (Eng)
• Final Tagless vs Free Monad (Talk, Rus) | Slides (Eng)
• Automatic Whitebox Testing with Free Monads (Talk, Eng) | Slides (Eng)
• Automatic whitebox testing with Free Moands (Showcase, Article)

Special Thanks

Special thanks to these folks who made a good contribution into Hydra directly or indirectly:

• Alexander Vershilov
• Vasily Gorev
• Sergey Stepanenko
• Kirill Havryliuk
• Vladislav Sabanov
• Evgeniy Tokarev