.. -package:configuration-tools

An infix timeIntervalBuilder.

Allows to apply function to result of another function with multiple arguments.

>>> (show ... (+)) 1 2
"3"

>>> show ... 5
"5"

>>> (null ... zip5) [1] [2] [3] [] [5]
True

Inspired by http://stackoverflow.com/questions/9656797/variadic-compose-function.

Performance

To check the performance there was done a bunch of benchmarks. Benchmarks were made on examples given above and also on the functions of many arguments. The results are showing that the operator (...) performs as fast as plain applications of the operator (.) on almost all the tests, but (...) leads to the performance draw-down if ghc fails to inline it. Slow behavior was noticed on functions without type specifications. That's why keep in mind that providing explicit type declarations for functions is very important when using (...). Relying on type inference will lead to the situation when all optimizations disappear due to very general inferred type. However, functions without type specification but with applied INLINE pragma are fast again.

Handy synonym for rangeInclusive Seq. Similar to .. for list.

>>> Ix1 4 ... 10
Array D Seq (Sz1 7)
[ 4, 5, 6, 7, 8, 9, 10 ]

Handy synonym for range Seq

>>> Ix1 4 ..: 10
Array D Seq (Sz1 6)
[ 4, 5, 6, 7, 8, 9 ]

Generate an infinite progression, starting from a given element, similar to [x..]. For better user experience consider enabling {-# LANGUAGE PostfixOperators #-}:

>>> :set -XPostfixOperators

>>> Data.List.Infinite.take 10 (0...)
[0,1,2,3,4,5,6,7,8,9]

Beware that for finite types (...) applies cycle atop of [x..]:

>>> :set -XPostfixOperators

>>> Data.List.Infinite.take 10 (EQ...)
[EQ,GT,EQ,GT,EQ,GT,EQ,GT,EQ,GT]

Remember that Int is a finite type as well. One is unlikely to hit this on a 64-bit architecture, but on a 32-bit machine it's fairly possible to traverse ((0 :: Int) ...) far enough to encounter 0 again.

Generate an infinite arithmetic progression, starting from given elements, similar to [x,y..]. For better user experience consider enabling {-# LANGUAGE PostfixOperators #-}:

>>> :set -XPostfixOperators

>>> Data.List.Infinite.take 10 ((1,3)....)
[1,3,5,7,9,11,13,15,17,19]

Beware that for finite types (....) applies cycle atop of [x,y..]:

>>> :set -XPostfixOperators

>>> Data.List.Infinite.take 10 ((EQ,GT)....)
[EQ,GT,EQ,GT,EQ,GT,EQ,GT,EQ,GT]

Remember that Int is a finite type as well: for a sufficiently large step of progression y - x one may observe ((x :: Int, y)....) cycling back to emit x fairly soon.

create a normalised space from two elements

create a normalised space from two elements

Creates the list of time units in descending order by provided the highest and the lowest bound of the desired list. Throws the error when time units are not in the right order. Usage example:

>>> seriesF @(Hour ... Second) $ hour 3 +:+ minute 5 +:+ sec 3 +:+ ms 123
"3h5m3+123/1000s"

Create a directed interval.

Create a non-empty interval, turning it around if necessary

Given a value and a proof, attach the proof as a ghost proof on the value.

Apply an implication to the ghost proof attached to a value, leaving the value unchanged.

Take a simple function with one named argument and a named return, plus an implication relating a precondition to a postcondition of the function, and produce a function between refined input and output types.

newtype NonEmpty xs = NonEmpty Defn
type role Nonempty nominal -- disallows coercion of Nonempty's argument.

newtype Reverse  xs = Reverse  Defn
type role Reverse nominal

rev :: ([a] ~~ xs) -> ([a] ~~ Reverse xs)
rev xs = defn (reverse (the xs))

rev_nonempty_lemma :: NonEmpty xs -> Proof (NonEmpty (Reverse xs))

rev' :: ([a] ?NonEmpty) -> ([a] ?NonEmpty)
rev' = rev ...? rev_nonempty_lemma

Compose composed with compose operator.

(f ... g) x y === f (g x y)

WarningParser version of .!=.

Synonym version of ..:.

Synonym version of ..:?.

WarningParser version of .:.

WarningParser version of .:?.