Tacit programming, also calledpoint-free style, is aprogramming paradigm in which function definitions do not identify thearguments (or "points") on which they operate. Instead the definitions merelycompose other functions, among which arecombinators that manipulate the arguments. Tacit programming is of theoretical interest, because the strict use of composition results in programs that are well adapted forequational reasoning.[1] It is also the natural style of someprogramming languages, includingAPL and its derivatives,[2] andconcatenative languages such asForth. The lack of argument naming gives point-free style a reputation of being needlessly obscure, hence theepithet "pointless style".[1]
Unixscripting uses the paradigm withpipes.
Tacit programming can be illustrated with the followingPython code. A sequence of operations such as the following:
defexample(x):returnbaz(bar(foo(x)))
... can be written in point-free style as the composition of a sequence of functions, without parameters:[3]
fromfunctoolsimportpartial,reducedefcompose(*functions):returnpartial(reduce,lambdax,f:f(x),functions)example=compose(foo,bar,baz)
For a more complex example, theHaskell codep = ((.) f) . g can be translated as:
p = partial(compose, partial(compose, f), g)
A simple example (inHaskell) is a program which computes the sum of a list of numbers. We can define the sum function recursively using apointed style (cf.value-level programming) as:
sum[]=0sum(x:xs)=x+sumxs
However, using afold, this can be replaced with:
sumxs=foldr(+)0xs
And then the argument is not needed, so this simplifies to
sum=foldr(+)0
which is point-free.
Another example usesfunction composition:
pxyz=f(gxy)z
The following Haskell-likepseudocode exposes how to reduce a function definition to its point-free equivalent:
p=\x->\y->\z->f(gxy)z=\x->\y->f(gxy)=\x->\y->(f.(gx))y=\x->f.(gx)(*Heretheinfixcomposeoperator"."isusedasacurriedfunction.*)=\x->((.)f)(gx)=\x->(((.)f).g)xp=((.)f).g
Finally, to see a complex example imagine a map filter program which takes a list, applies a function to it, and then filters the elements based on a criterion
mfcriteriaoperatorlist=filtercriteria(mapoperatorlist)
It can be expressed point-free[4] as
mf=(.map).(.).filter
As suggested already, the points inpoint-free refer to the arguments, not to the use of dots; a common misconception.[5]
A few programs have been written to automatically convert a Haskell expression to a point-free form.
In the languageJ, the same sort of point-free code occurs in a function made to compute the average of a list (array) of numbers:
avg=:+/%#
+/ sums the items of the array by mapping (/) summation (+) to the array.% divides the sum by the number of elements (#) in the array.
Euler's formula expressed tacitly:
cos=:2o.]sin=:1o.]Euler=:^@j.=cosj.sin
(j. is a primitive function whose monadic definition is0j1 times x and whose dyadic definition isx+0j1×y.) The same tacit computations expressed inDyalog APL:
avg←+⌿÷≢cos←2○⊢sin←1○⊢EulerCalc←cos+0j1×sin⍝ 0j1 is what's usually written as iEulerDirect←*0J1×⊢⍝ Same as ¯12○⊢⍝ Do the 2 methods produce the same result?EulerCheck←EulerDirect=EulerCalcEulerCheck¯11231111⍝ Yes, so far so good!
Instack-oriented programming languages (andconcatenative ones, most of which are stack based[citation needed]), point-free methods are commonly used. For example, a procedure to compute theFibonacci numbers might look like the following inPostScript:
/fib{dupdup1eqexch0eqornot{dup1subfibexch2subfibadd}if}def
In Unix scripting the functions are computer programs which receive data fromstandard input and send the results tostandard output. For example,
sort | uniq -c | sort -rn
is a tacit or point-free composition which returns the counts of its arguments and the arguments, in the order of decreasing counts. Thesort anduniq are the functions, the-c and-rn control the functions, but the arguments are not mentioned. The pipe| is the composition operator.
Due to the way pipelines work, it is normally possible only to pass oneargument at a time in the form of a pair of standardinput/output stream. Although extrafile descriptors can be opened fromnamed pipes, this no longer constitutes a point-free style.
jq is aJSON-oriented programming language in which the| symbol is used to connect filters to form a pipeline in a familiar way. For example:
[1,2] | add
evaluates to 3. (Yes, the JSON array is a jq filter that evaluates to an array.)
Although similar to Unix pipelines, jq pipelines allow the incoming data to be sent to more than one recipient on the RHS of the| as though in parallel. For example, the programadd/length will compute the average of the numbers in an array, so that:
[1,2] | add/length
evaluates to 1.5
Similarly:
[1,2] | [length, add, add/length]
evaluates to [2,3,1.5]
A dot (.) can be used to define an attachment point on the RHS, e.g.:
1 | [., .]
evaluates to [1,1]
and similarly:
2 | pow(.; .)
evaluates to 4 sincepow(x;y) is x to the power y.
A tacit jq program for generating the Fibonacci sequence would be:
[0,1] | recurse( [last, add] ) | first
Here,[0,1] is the initial pair to be taken as the first two itemsin the Fibonacci sequence. (The pair[1,1] could likewise be used forthe variant definition.)
The alphabetic tokens are built-in filters: `first` and `last`emit the first and last elements of their input arrays respectively;andrecurse(f) applies a filter, f, to its input recursively.
jq also allows new filters to be defined in a tacit style, e.g.:
def fib: [0,1] | recurse( [last, add] ) | first;
In the section on Python in this article, the following Python definition is considered:
defexample(x):returnbaz(bar(foo(x)))
In point-free style, this can be written in Python as:
example = compose(foo, bar, baz)
In jq, the equivalent point-free definition would be:
def example: foo | bar | baz;