Content deleted Content added
mNo edit summary |
add Rust reference |
||
Line 1:
'''Uniform Function Call Syntax''' (UFCS) or sometimes '''Universal Function Call Syntax''' is a [[programming language]] feature in [[D (programming language)|D]] and [[Rust (programming language)|Rust]]<ref>https://doc.rust-lang.org/book/ufcs.html</ref> that allows any 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>http://dlang.org/function.html#pseudo-member</ref> UFCS is particularly useful when function calls are chained,<ref>http://ddili.org/ders/d.en/ufcs.html</ref> behaving similar to pipes, or various dedicated operators available in functional languages for passing values through an expression. It allows free-functions to fills 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, dependant on the context. When the programmer starts with an argument, the set of potentially applicable functions is greatly narrowed down, aiding discoverability.
Line 35:
// Chaining
int[] e = a.addone().addone();
}
</source>
=== Rust programming language ===
<source lang="Rust">
trait Foo {
fn f(&self);
fn g(&self);
}
trait Bar {
fn g(&self);
}
struct Qux;
impl Foo for Qux {
fn f(&self) { println!("Qux’s implementation of Foo::f"); }
fn g(&self) { println!("Qux’s implementation of Foo::g"); }
}
impl Bar for Qux {
fn g(&self) { println!("Qux’s implementation of Bar::g"); }
}
fn main() {
let q = Qux;
// These two are equivalent:
q.f();
Foo::f(&q);
// This would not work because .g() is ambiguous:
// q.g();
// But it's possible to disambiguate using UFCS
Foo::g(&q);
Bar::g(&q);
}
</source>
| |||