function-builder: Create poly variadic functions for monoidal results

[ bsd3, data-structures, library ] [ Propose Tags ]

Please see

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS],,,,,,,,,
Change log
Dependencies base (>=4.11 && <5), tagged (>=0.8 && <0.9) [details]
License BSD-3-Clause
Copyright 2019 Sven Heyll
Author Sven Heyll
Category Data Structures
Home page
Source repo head: git clone
Uploaded by SvenHeyll at 2019-02-06T00:26:12Z
Distributions LTSHaskell:, NixOS:, Stackage:
Reverse Dependencies 1 direct, 0 indirect [details]
Downloads 4914 total (32 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2019-02-06 [all 1 reports]

Readme for function-builder-

[back to package description]

Build Status


A library for making Monoid writing functions with variable number of parameters

Also known as: Holey monoids.

This library is made to be useful especially for library authors, who want to provide users with building blocks to create functions that compose a monoidal structure from their parameters in a type safe way. Think of printf.

This library allows the author of such a library to easily add the building blocks, allowing users to build poly variadic functions, i.e. with parameters depending on the order and composition of these building blocks.

Several FunctionBuilder values sharing a common monoidal output type can be composed to a big FunctionBuilder value, in order to build an output function that has a flexible number and types of parameters depending, on the individual FunctionBuilders used. This output function can be obtained by toFunction.

FunctionBuilders can also be composed via standard type classes.

This module gives you ready-made Functor, Applicative, Semigroup, Monoid and Category` instances;

For example, this library could be used to build a string formatting library, that allows users to compose arbitrary, printf-style render functions from reusable building blocks, such that they can be re-combined in order to make get functions, that can be applied to parameters that fill place holders, like e.g.:

 module AStringFormatter where

 str :: String -> FunctionBuilder String next next
 str = immediate

 renderInt :: FunctionBuiler String next (Int -> next)
 renderInt = deferred show

 renderFloat :: FunctionBuiler String next (Float -> next)
 renderFloat = ...

Then the user of YourStringFormatter can write:

 module CpuTempFormatter where

 import AStringFormatter

 renderCpuTemp :: Int -> Float -> String
 renderCpuTemp =
   toFunction (str "CPU " . renderInt . str " Temperature: " . renderFloat)

Similar Libraries

  • polyToMonoid

  • HoleyMonoid

  • formatting

  • category-printf I learned from the author of that library Cale Gibbard in this reddit comment that the Format type in that library (called FunctionBuilder in this library) is an alias for

    "(...)the cokleisli category for the comonad of functions on a monoid, which is already in the comonad library"