Uniform Function Call Syntax (UFCS) or Uniform Calling Syntax (UCS) or sometimes Universal Function Call Syntax is a
programming language feature in
D and
Nim
Nim is a mathematical two player game.
Nim or NIM may also refer to:
* Nim (programming language)
* Nim Chimpsky, a signing chimpanzee Acronyms
* Network Installation Manager, an IBM framework
* Nuclear Instrumentation Module
* Negative index met ...
that allows any
function to be called using the syntax for method calls (as in
object-oriented programming), by using the
receiver as the first parameter, and the given arguments as the remaining parameters. UFCS is particularly useful when function calls are chained (behaving similar to
pipes, or the various dedicated
operator
Operator may refer to:
Mathematics
* A symbol indicating a mathematical operation
* Logical operator or logical connective in mathematical logic
* Operator (mathematics), mapping that acts on elements of a space to produce elements of another ...
s available in
functional languages for passing values through a series of
expressions). It allows free-functions to fill a role similar to
extension methods in some other languages. Another benefit of the method call syntax is use with "
dot-autocomplete" in
IDEs, which use type information to show a list of available functions, dependent on the context. When the programmer starts with an argument, the set of potentially applicable functions is greatly narrowed down,
aiding
discoverability.
Examples
Nim programming language
type Vector = tuple , y: int
proc add(a, b: Vector): Vector =
(a.x + b.x, a.y + b.y)
let
v1 = (x: -1, y: 4)
v2 = (x: 5, y: -2)
# all the following are correct
v3 = add(v1, v2)
v4 = v1.add(v2)
v5 = v1.add(v2).add(v4)
D programming language
import std.stdio;
int first(int[] arr)
int[] addone(int[] arr)
void main()
C++ proposal
Proposals for a unification of member function and free function calling syntax have been discussed from the early years of C++ standardization. Glassborow (2004) proposed a Uniform Calling Syntax (UCS), allowing specially annotated free functions to be called with member function notation.
It has more recently been proposed (as of 2016) for addition to C++ by
Bjarne Stroustrup and
Herb Sutter,
[ to reduce the ambiguous decision between writing free functions and member functions, to simplify the writing of templated code. Many programmers are tempted to write member functions to get the benefits of the member function syntax (e.g. " dot-autocomplete" to list member functions); however, this leads to excessive coupling between classes.]
Rust usage of the term
Until 2018 it was common to use this term when actually referring to
qualified/explicit path syntax
' and most commonly the
'': because it's possible to have several traits defining the same method implemented on the same struct, a mechanism is needed to disambiguate which trait should be used.
Member functions can also be used as free functions through a qualified (namespaced) path.
The term UFCS is incorrect for these uses, as it allows using methods as (namespaced) free functions, but not using free functions as methods.
See also
* Trait (computer programming)
* Interface (computer programming)
In object-oriented programming, an interface or protocol type is a data type describing a set of method signatures, the implementations of which may be provided by multiple classes that are otherwise not necessarily related to each other. A clas ...
* Go (programming language), another language with a more open philosophy to methods
* Loose coupling
* Duck typing
* Method chaining
References
{{Reflist
Object-oriented programming
Source code
Subroutines
Articles with example code