Updated ufcs.md

hanbum authored
revision 7ddda0acea6874b0490d38b16ff59ef62b236198
ufcs
# 5.24. 전역 함수 사용법 (Universal Function Call Syntax) - 0%

종종, 함수들은 동일한 이름을 갖게 된다. 다음 코드를 살펴보자:
Sometimes, functions can have the same names. Consider this code:

```rust
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;
```

우리가 `b.f()`를 호출하고자 하면, 다음의 에러를 얻게 된다:
If we were to try to call `b.f()`, we’d get an error:

```text
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:

```rust
# 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;
Foo::f(&b);
Bar::f(&b);
```

나눠서 살펴보자.
Let’s break it down.

```rust,ignore
Foo::
Bar::
```

호출문의 절반은 두 트레잇들이다: `Foo`와 `Bar`. 이들의 끝 부분이 실제로 어떤 일을 할지를 결정한다: 러스트는 사용된 트레잇 이름에서 호출하게 된다.
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.

```rust,ignore
f(&b)
```

우리가 메소드를 `b.f()`같이 [method syntax][methodsyntax]를 사용하여 호출하게 되면, 러스트는 `f()`가 `&self`를 취할 경우 자동으로 `b`를 대여한다. 이번 경우에는, 러스트는 하지 않을 것이고, 그렇기에 우리는 `&b`를 명시적으로 전달할 필요가 있다.
When we call a method like `b.f()` using [method syntax][methodsyntax], Rust
will automatically borrow `b` if `f()` takes `&self`. In this case, Rust will
not, and so we need to pass an explicit `&b`.

[methodsyntax]: method-syntax.html

# Angle-bracket Form
꺾쇄 괄호 형태( <> )

이번에 얘기하고자 하는 UFCS(Universal Function Call Syntax : 전역 함수 호출 문법)이다:

The form of UFCS we just talked about:

```rust,ignore
Trait::method(args);
```

이는 줄여쓴 것이다. 어떤 상황에는 확장된 형식을 사용해야 할 필요가 있다.
Is a short-hand. There’s an expanded form of this that’s needed in some
situations:

```rust,ignore
::method(args);
```

`<>::` 문법은 타입의 힌트를 제공한다. `<>`안에 타입이 들어가게 된다. 이번 경우에 타입은 `Type as Trait`이고, `Trait`의 `method` 를 호출하는 버전을 보여주고자 한다. `as Trait` 부분은 부가적인 것으로 타입이 모호하지 않다면 빼도 된다. 꺾쇄 괄호 외엔 줄여쓴 형태와 같다.
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.

```rust
trait Foo {
fn clone(&self);
}

#[derive(Clone)]
struct Bar;

impl Foo for Bar {
fn clone(&self) {
println!("Making a clone of Bar");

::clone(self);
}
}
```

이는 `Foo` 대신 `Clone` 트레잇의 `clone()`을 호출할 것이다.
This will call the `Clone` trait’s `clone()` method, rather than `Foo`’s.