autoapply: Template Haskell to automatically pass values to functions

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]



[Skip to Readme]


Versions,, 0.3, 0.4, 0.4.1, 0.4.1,,
Change log
Dependencies base (>=4.12 && <5), logict, mtl, template-haskell, th-desugar (>=1.11 && <1.12), transformers, unification-fd [details]
License BSD-3-Clause
Copyright (c) 2020 Joe Hermaszewski
Maintainer Joe Hermaszewski <>
Category Template Haskell
Home page
Bug tracker
Source repo head: git clone
Uploaded by jophish at 2020-08-26T11:10:05Z


[Index] [Quick Jump]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Readme for autoapply-0.4.1

[back to package description]


A Template-Haskell program to automatically pass arguments to functions wherever the type fits.

@tomjaguarpaw noticed that this is like "Type-directed implicit parameters".


You have the following values and want to stir them together and see what sticks.

$(autoApply [] ['getA, 'myC] 'foo) will create \b -> getA >>= \a -> foo a b myC which has type B -> App D


autoApplyDecs reverse [] ['getA, 'myC] ['foo] will create oof :: B -> App D; oof b = do { a <- getA; foo a b myC }

Why to use it

One nice use-case is to avoiding writing boilerplate wrappers for using an API in your Monad stack. For instance imagine the following API.

data Instance; data ExtraOpenInfo; data Foo; data Bar; data Handle
openHandle  :: MonadIO m => Instance -> Maybe ExtraOpenInfo -> m Handle
closeHandle :: MonadIO m => Instance -> Handle -> m ()
useHandle   :: MonadIO m => Instance -> Handle -> Foo -> m Bar

You'd like to use this in your polysemy application, using the Input effect to pass the Instance handle around, and always passing Nothing for ExtraOpenInfo because you don't use that functionality and getting a Foo from some other constraint MyConstraint. You define the following values.

myExtraOpenInfo :: Maybe ExtraOpenInfo
myExtraOpenInfo = Nothing
getInstance :: Member (Input Instance) r => Sem r Instance
getInstance = input
getFoo :: MyConstraint m => m Foo
getFoo = ...

You then create the wrapped API thusly:

  (<> "'") -- Function to transform the names of the wrapped functions
  ['myExtraOpenInfo, 'getInstance, 'getFoo]
    -- Potential arguments to pass which must subsume the argument type of the
    -- function.
  [] -- Potential arguments to pass which must unify with the argument type
  ['openHandle, 'closeHandle, 'useHandle] -- Functions to wrap

Which creates the following declarations:

  :: (Member (Input Instance) r, MonadIO (Sem r)) => Sem r Handle
  :: (Member (Input Instance) r, MonadIO (Sem r)) => Handle -> Sem r ()
  :: (Member (Input Instance) r, MyConstraint (Sem r), MonadIO (Sem r))
  => Handle -> Sem r Bar


To see the generated code (it's exactly what you'd expect) compile test/Types.hs with -ddump-splices.

How to use this

To generate a new top-level declaration you'll need:

The new declaration will be generated, equal to the wrapped one but using the supplied arguments wherever possible.

Arguments can be used in two ways:

It's important to note that Monad instance checking only goes as far as template-haskell's reifyInstances. i.e. only the instance heads are checked.

Constraints are checked (up to reifyInstances) so it won't pass reverse to (+) for example.

Monadic binds are performed in the order of arguments passed to the wrapped function, and will be performed more than once if the argument is used multiple times.

You may want to either type your generated declarations manually (putting the type after the splice) or turn on -XNoMonomorphismRestriction if your arguments have polymorphic constraints.

Where to use it

See also

This has a similar feel to some other programs which also generate Haskell expressions based on types.

There are a couple of differences here: