program: Programs with Environments and Managed Resources

[ bsd3, control, library ] [ Propose Tags ]

Please see the README on GitHub at

[Skip to Readme]


Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'.

Maintainer's Corner

For package maintainers and hackage trustees


Versions [RSS]
Change log
Dependencies base (>=4.13 && <5) [details]
License BSD-3-Clause
Copyright 2021 Michael Szvetits
Author Michael Szvetits
Revised Revision 1 made by MichaelSzvetits at 2021-12-03T12:57:54Z
Category Control
Home page
Bug tracker
Source repo head: git clone
Uploaded by MichaelSzvetits at 2021-12-02T16:14:35Z
Distributions NixOS:
Downloads 81 total (3 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2021-12-02 [all 1 reports]

Readme for program-

[back to package description]




program is a library for writing programs with environments and managed resources, written in Haskell. It aims to be simple, has minimal dependencies and combines features of various existing approaches for threading an environment through an application (e.g., RIO, ReaderT, Handle Pattern, record-of-functions) and for managing resources without nested bracket-functions (e.g., managed). The library and its documentation can be found on Hackage.


The following simple example copies count characters from one file to another, where count is demanded from the environment e by the function copy (via pull) and supplied by main. Note that we do not need to close file handles, because resources are managed automatically.

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeOperators    #-}
module Example where

-- base
import Control.Monad
import Control.Monad.IO.Class
import System.IO

-- program
import Control.Program (Program, Has, manage, pull, runProgram)

copy :: e `Has` Int => FilePath -> FilePath -> Program e ()
copy from to = do
  fromHandle <- manage (withFile from ReadMode)
  toHandle   <- manage (withFile to WriteMode)
  count      <- pull
  liftIO . replicateM_ count $
    hGetChar fromHandle >>= hPutChar toHandle

main :: IO ()
main = do
    ( 10 :: Int )
    ( copy "/tmp/source" "/tmp/target" )

In larger applications, the environment would contain many more complex values (all demanded by Has) and can also be used to manage mutable state. See the documentation on Hackage for more details.


  • Easy to understand (e.g., no unlifting, no type-level wizardry, hardly any language extensions).
  • No need for extra dependencies. All we need is base.
  • Mocking is easy by supplying different environments via runProgram.
  • No fight with the type inference (i.e., down-to-earth types, hardly any typeclasses).
  • The environment can easily simulate beloved effects like Reader and State.
  • Easy integration of other effects by putting records-of-functions into the environment.
  • Clear error message because involved types are not overly generic.