ltext: Parameterized file evaluator

[ bsd3, filesystem, library, program, text, tools, utils ] [ Propose Tags ]

Please see the README on GitHub at https://github.com/githubuser/template-dictionary#readme


[Skip to Readme]
Versions 0.0.0.1, 0.0.0.2, 0.0.0.3, 0.0.0.4, 0.0.0.5, 0.0.1, 0.0.1.1, 0.0.1.2, 0.0.2, 0.0.2.1, 0.1.0, 0.1.1, 0.1.2, 0.1.2.1, 0.1.2.2, 0.1.3 (info)
Dependencies attoparsec, base (>=4.11 && <5), directory, exceptions, extra, ltext, mtl, optparse-applicative, pretty, QuickCheck, quickcheck-combinators (>=0.0.5), quickcheck-instances, text, transformers, unordered-containers [details]
License BSD-3-Clause
Copyright 2018 (c) Local Cooking Inc.
Author Athan Clark
Maintainer athan.clark@localcooking.com
Category Text
Home page https://github.com/ltext/ltext#readme
Bug tracker https://github.com/ltext/ltext/issues
Source repo head: git clone https://github.com/ltext/ltext
Uploaded by athanclark at Sat Nov 3 06:53:36 UTC 2018
Distributions NixOS:0.1.3
Executables ltext
Downloads 3748 total (65 in the last 30 days)
Rating (no votes yet) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2018-11-03 [all 1 reports]
Hackage Matrix CI

Modules

[Index] [Quick Jump]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for ltext-0.1.3

[back to package description]

ltext

λtext

General-Purpose Templating Utility

Overview

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

Building

$> git clone git@github.com/ltext/ltext
$> cd ltext
$> stack install ltext

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

Usage

$> 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
  http://ltext.github.io/ 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
                           header
  --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.

The CLI

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"

Credits

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