Uniform function call syntax: Difference between revisions

Revision as of 13:30, 1 October 2017

Revision as of 00:36, 11 August 2018

Line 1:

{{Primary sources|date=September 2017}}

'''Uniform Function Call Syntax''' ('''UFCS''') or sometimes '''Universal Function Call Syntax''' is a [[programming language]] feature in [[D (programming language)|D]] and [[Nim (programming language)|Nim]] that allows any [[function (computer programming)|function]] to be called using the syntax for method calls (as in [[object-oriented programming]]), by using the [[receiver (object oriented programming)|receiver]] as the first parameter, and the given arguments as the remaining parameters.<ref>{{cite web|url=http://dlang.org/function.html#pseudo-member|title=Functions - D Programming Language|website=Dlang.org|accessdate=1 October 2017}}</ref> UFCS is particularly useful when function calls are chained<ref>{{cite web|url=http://ddili.org/ders/d.en/ufcs.html|title=Programming in D - Universal Function Call Syntax (UFCS)|website=Ddili.org|accessdate=1 October 2017}}</ref> (behaving similar to [[Pipe (computer science)|pipe]]s, or the various dedicated [[Operator (computer programming)|operator]]s available in [[functional language]]s for passing values through a series of [[Expression (computer science)|expression]]s). It allows free-functions to fill a role similar to [[extension method]]s in some other languages. Another benefit of the method call syntax is use with "[[dot-autocomplete]]" in [[IDE (computing)|IDE]]s, 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,<ref name="auto">{{cite web|title="Unified Call Syntax"|url=https://isocpp.org/files/papers/N4165.pdf|format=PDF|website=Isocpp.org|accessdate=1 October 2017}}</ref> aiding discoverability.

'''Uniform Function Call Syntax''' ('''UFCS''') or sometimes '''Universal Function Call Syntax''' is a [[programming language]] feature in [[D (programming language)|D]], [[Rust (programming language)|Rust]]<ref>{{cite web|url=https://doc.rust-lang.org/book/first-edition/ufcs.html|title=Universal Function Call Syntax - The Rust Programming Language|website=Doc.rust-lang.org|accessdate=1 October 2017}}</ref> and [[Nim (programming language)|Nim]] that allows any [[function (computer programming)|function]] to be called

using the syntax for method calls (as in [[object-oriented programming]]), by using the [[receiver (object oriented programming)|receiver]] as the first parameter, and the given arguments as the remaining parameters.<ref>{{cite web|url=http://dlang.org/function.html#pseudo-member|title=Functions - D Programming Language|website=Dlang.org|accessdate=1 October 2017}}</ref> UFCS is particularly useful when function calls are chained<ref>{{cite web|url=http://ddili.org/ders/d.en/ufcs.html|title=Programming in D - Universal Function Call Syntax (UFCS)|website=Ddili.org|accessdate=1 October 2017}}</ref> (behaving similar to [[Pipe (computer science)|pipe]]s, or the various dedicated [[Operator (computer programming)|operator]]s available in [[functional language]]s for passing values through a series of [[Expression (computer science)|expression]]s). It allows free-functions to fill a role similar to [[extension method]]s in some other languages. Another benefit of the method call syntax is use with "[[dot-autocomplete]]" in [[IDE (computing)|IDE]]s, 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,<ref name="auto">{{cite web|title="Unified Call Syntax"|url=https://isocpp.org/files/papers/N4165.pdf|format=PDF|website=Isocpp.org|accessdate=1 October 2017}}</ref> aiding discoverability.

== C++ proposal ==

It has been proposed (as of 2016) for addition to C++ by [[Bjarne Stroustrup]]<ref>{{cite web|title="UFCS proposal"|url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4174.pdf|format=PDF|website=Open-std.org|accessdate=1 October 2017}}</ref> and [[Herb Sutter]]<ref name="auto"/>, to reduce the ambiguous decision between writing [[free function (c++)|free function]]s and member functions, to simplify the writing of [[generic programming|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 function]]s);<ref>{{cite web|title=using intellisense|url=https://msdn.microsoft.com/en-us/library/hcw1s69b.aspx|website=Msdn.microsoft.com|accessdate=1 October 2017}}</ref> however, this leads to excessive [[Coupling (computer programming)|coupling]] between [[Class (computer programming)|classes]].<ref>{{cite web|title="How Non-Member Functions improve encapsulation|url=http://www.drdobbs.com/cpp/how-non-member-functions-improve-encapsu/184401197|website=Drdobbs.com|accessdate=1 October 2017}}</ref>

== Rust usage of the term ==

Until 2018 it was common to use this term when actually referring to the ''[https://doc.rust-lang.org/book/2018-edition/ch19-03-advanced-traits.html?highlight=trait,function,call#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name Fully Qualified Syntax for Disambiguation].'' In Rust many traits can implement functions with the same name for a given type, so a mechanism is required to tell the compiler which one it should use. However it's a very specific feature that only applies to '''trait functions''' but not to free or member functions.

== Examples ==

Line 36 ⟶ 38:

// Chaining

int[] e = a.addone().addone();

}

</source>

=== Rust programming language ===

<source lang="Rust">

trait Foo {

fn a(&self);

fn b(&self);

}

trait Bar {

fn b(&self);

}

struct Qux;

impl Foo for Qux {

fn a(&self) { println!("Qux’s implementation of Foo::a"); }

fn b(&self) { println!("Qux’s implementation of Foo::b"); }

}

impl Bar for Qux {

fn b(&self) { println!("Qux’s implementation of Bar::b"); }

}

fn main() {

let c = Qux;

// These two are equivalent:

c.a();

Foo::a(&c);

// This would not work because .b() is ambiguous:

// c.b();

// But it's possible to disambiguate using UFCS

Foo::b(&c);

Bar::b(&c);

}

</source>