Rust의 기본 함수 인수

Rust의 기본 함수 인수

---

Rust에서 기본 인자로 함수를 만드는 것이 가능합니다?

fn add(a: int = 1, b: int = 2) { a + b }

---

아니요, 현재는 아닙니다. 언젠가는 구현 될 것 같지만 현재이 공간에서 활활 한 작업은 없습니다.

여기에 사용되는 일반적인 기술은 이름과 서명이 다른 함수 나 메서드를 사용하는 것입니다.

---

기본 인수가 지원되지 않으므로 다음을 사용하여 동작을받을 수 있습니다. Option<T>

fn add(a: Option<i32>, b: Option<i32>) -> i32 {
    a.unwrap_or(1) + b.unwrap_or(2)
}

이렇게하면 많은 작업과 함수를 한 번만 코딩하는 목표를 달성하지만 (모든 호출 대신) 물론 입력해야 할 훨씬 더 많은 작업입니다. 함수 호출은처럼 보이며 add(None, None), 관점에 따라 좋아할 수도 있고 않을 수도 있습니다.

코더가 특별한 경우 선택을하는 것을 잊었 기 때문에 인수 목록에 아무것도 입력하지 않는 것을 본다면 여기서 큰 이점은 명시성에 있습니다. 호출자는 기본 값으로 가고 싶다고 명시 적으로 명시 적으로 말 오류가 발생합니다. 타이핑으로 생각하십시오 add(DefaultValue, DefaultValue).

매크로를 사용할 수도 있습니다.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

macro_rules! add {
    ($a: expr) => {
        add($a, 2)
    };
    () => {
        add(1, 2)
    };
}

assert_eq!(add!(), 3);
assert_eq!(add!(4), 6);

두 솔루션의 큰 차이점은 "Option"-al 인수를 사용하면 작성하는 것이 완전히 유효 add(None, Some(4))하지만 매크로 패턴이 일치하면 불가능한 것입니다 (파이썬의 기본 인수 규칙과 유사합니다).

"arguments"구조체와 From/ Into특성을 사용할 수도 있습니다 .

pub struct FooArgs {
    a: f64,
    b: i32,
}

impl Default for FooArgs {
    fn default() -> Self {
        FooArgs { a: 1.0, b: 1 }
    }
}

impl From<()> for FooArgs {
    fn from(_: ()) -> Self {
        Self::default()
    }
}

impl From<f64> for FooArgs {
    fn from(a: f64) -> Self {
        Self {
            a: a,
            ..Self::default()
        }
    }
}

impl From<i32> for FooArgs {
    fn from(b: i32) -> Self {
        Self {
            b: b,
            ..Self::default()
        }
    }
}

impl From<(f64, i32)> for FooArgs {
    fn from((a, b): (f64, i32)) -> Self {
        Self { a: a, b: b }
    }
}

pub fn foo<A>(arg_like: A) -> f64
where
    A: Into<FooArgs>,
{
    let args = arg_like.into();
    args.a * (args.b as f64)
}

fn main() {
    println!("{}", foo(()));
    println!("{}", foo(5.0));
    println!("{}", foo(-3));
    println!("{}", foo((2.0, 6)));
}

이 선택은 분명히 훨씬 더 많은 코드이지만 매크로 디자인과 달리 유형 시스템을 사용하므로 컴파일러 오류가 라이브러리 / API 사용자에게 더 도움이 될 것입니다. 이것은 또한 From도움이되는 경우 사용자가 직접 구현할 수 있도록합니다.

---

아니요, Rust는 기본 함수 인수를 지원하지 않습니다. 다른 이름으로 다른 메서드를 정의해야합니다. Rust는 함수 이름을 사용하여 유형을 파생하기 때문에 함수 오버로딩도 없습니다 (함수 오버로딩에는 반대가 필요함).

구조체 초기화의 경우 다음과 같은 구조체 업데이트 구문을 사용할 수 있습니다.

use std::default::Default;

#[derive(Debug)]
pub struct Sample {
    a: u32,
    b: u32,
    c: u32,
}

impl Default for Sample {
    fn default() -> Self {
        Sample { a: 2, b: 4, c: 6}
    }
}

fn main() {
    let s = Sample { c: 23, .. Sample::default() };
    println!("{:?}", s);
}

[요청시 중복 질문에서이 답변을 교차 게시했습니다.]

---

Rust 1.12 이상을 사용하고 있다면 최소한 함수 인자를 Optionand 와 함께 사용하기 쉽게 만들 수 있습니다 into().

fn add<T: Into<Option<u32>>>(a: u32, b: T) -> u32 {
    if let Some(b) = b.into() {
        a + b
    } else {
        a
    }
}

fn main() {
    assert_eq!(add(3, 4), 7);
    assert_eq!(add(8, None), 8);
}

---

Rust는 기본 함수 인수를 지원하지 않으며 앞으로 구현 될 것이라고 생각하지 않습니다. 그래서 매크로 형식으로 구현하기 위해 proc_macro duang 을 작성했습니다.

예를 들면 :

duang! ( fn add(a: i32 = 1, b: i32 = 2) -> i32 { a + b } );
fn main() {
    assert_eq!(add!(b=3, a=4), 7);
    assert_eq!(add!(6), 8);
    assert_eq!(add(4,5), 9);
}

참조 URL : https://stackoverflow.com/questions/24047686/default-function-arguments-in-rust