ltext: Parameterized file evaluator

[ bsd3, library, program, text ] [ Propose Tags ]

Please see the README on GitHub at

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS],,,,, 0.0.1,,, 0.0.2,, 0.1.0, 0.1.1, 0.1.2,,, 0.1.3, 0.1.4, 0.1.5 (info)
Dependencies attoparsec, base (>=4.11 && <5), directory, exceptions, extra, ltext, mtl, optparse-applicative, pretty, QuickCheck, quickcheck-instances, text, transformers, unordered-containers [details]
License BSD-3-Clause
Copyright 2014-2024 (c) Athan Clark
Author Athan Clark
Category Text
Home page
Bug tracker
Source repo head: git clone
Uploaded by athanclark at 2024-01-05T17:56:14Z
Reverse Dependencies 1 direct, 0 indirect [details]
Executables ltext
Downloads 8196 total (34 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2024-01-05 [all 1 reports]

Readme for ltext-0.1.5

[back to package description]



General-Purpose Templating Utility


λtext turns text files into higher-order functions, featuring a Hindley-Milner / prenex polymorphic type system. See the page.


$> git clone
$> cd ltext
$> stack install ltext

This should install in one pass; all the non-stackage dependencies are included in stack.yaml.

Using Nix

You can build with nix with the following command:

nix-build -A ltext.components.exes.ltext


$> ltext --help

λtext - parameterized file evaluator

Usage: ltext EXPRESSION [--version] [-t|--type] [-v|--verbose] [-r|--raw FILE]
             [--left LEFT] [--right RIGHT]
  Evaluate EXPRESSION and send the substitution to stdout. See for more details.

Available options:
  -h,--help                Show this help text
  --version                Print the version number
  -t,--type                Perform type inference on an expression
  -v,--verbose             Be verbose, sending info through stderr
  -r,--raw FILE            Treat these files as plaintext without an arity
  --left LEFT              The left delimiter to use for rendering partially
                           applied files
  --right RIGHT            The right delimiter to use for rendering partially
                           applied files

$> ltext --type "\a -> a"

a0 -> a0

How It Works

From λtext's point of view, any text file can be a template (given that it's utf-8 encoded). Just declare parameters in the first line of your files (usually in a different syntax than the file's native tongue, via comments or obscure delimiters), then use those variables somewhere in the content. With the ltext command you can then apply the function-y files to each other.


There will be two primary uses of the ltext command - evaluating template expressions, and querying for the type signature of a template/expression.

Type Queries

Just like the :t command in GHCi, you can find out the type of a template or expression with -t.

Expression Evaluation

All files have closed scope, meaning they only have access to the variables declared in the file. For instance:

{{ foo }}


Will only have access to the variable foo, while using the delimiters {{ and }} to escape your expression.

Variable Recognition

When we use a parameter in a file, we need it to be easily recognized by a parser; a different syntax than to the language you're working with.

The first line in a file will be parsed to see if it qualifies as a lambda header. If you don't want a file have recognized arity, just invoke ltext with the --raw argument listing the file:

$> ltext "foo bar" --raw "bar"


All credits go to Martin Grabmueller's AlgorithmW package for the type inference algorithm used in λtext.