4.3 KiB
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)
- CLI apps support
- 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.
Building dependencies
Ubuntu:
$ sudo apt-get install libpg-dev librocksdb-dev
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: