# Universal Function Call Syntax

Sometimes, functions can have the same names. Consider this code:

```trait Foo {
fn f(&self);
}

trait Bar {
fn f(&self);
}

struct Baz;

impl Foo for Baz {
fn f(&self) { println!("Baz’s impl of Foo"); }
}

impl Bar for Baz {
fn f(&self) { println!("Baz’s impl of Bar"); }
}

let b = Baz;Run```

If we were to try to call `b.f()`, we’d get an error:

``````error: multiple applicable methods in scope [E0034]
b.f();
^~~
note: candidate #1 is defined in an impl of the trait `main::Foo` for the type
`main::Baz`
fn f(&self) { println!("Baz’s impl of Foo"); }
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
note: candidate #2 is defined in an impl of the trait `main::Bar` for the type
`main::Baz`
fn f(&self) { println!("Baz’s impl of Bar"); }
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

``````

We need a way to disambiguate which method we need. This feature is called ‘universal function call syntax’, and it looks like this:

```Foo::f(&b);
Bar::f(&b);Run```

Let’s break it down.

```Foo::
Bar::Run```

These halves of the invocation are the types of the two traits: `Foo` and `Bar`. This is what ends up actually doing the disambiguation between the two: Rust calls the one from the trait name you use.

`f(&b)Run`

When we call a method like `b.f()` using method syntax, Rust will automatically borrow `b` if `f()` takes `&self`. In this case, Rust will not, and so we need to pass an explicit `&b`.

# Angle-bracket Form

The form of UFCS we just talked about:

`Trait::method(args);Run`

Is a short-hand. There’s an expanded form of this that’s needed in some situations:

`<Type as Trait>::method(args);Run`

The `<>::` syntax is a means of providing a type hint. The type goes inside the `<>`s. In this case, the type is `Type as Trait`, indicating that we want `Trait`’s version of `method` to be called here. The `as Trait` part is optional if it’s not ambiguous. Same with the angle brackets, hence the shorter form.

Here’s an example of using the longer form.

```trait Foo {
fn foo() -> i32;
}

struct Bar;

impl Bar {
fn foo() -> i32 {
20
}
}

impl Foo for Bar {
fn foo() -> i32 {
10
}
}

fn main() {
assert_eq!(10, <Bar as Foo>::foo());
assert_eq!(20, Bar::foo());
}Run```

Using the angle bracket syntax lets you call the trait method instead of the inherent one.