// This is a comment. Line comments look like this...
// and extend multiple lines like this.

/* Block comments
  /* can be nested. */ */

/// Documentation comments look like this and support markdown notation.
/// # Examples
///
/// ```
/// let five = 5
/// ```

///////////////
// 1. Basics //
///////////////

#[allow(dead_code)]
// Functions
// `i32` is the type for 32-bit signed integers
fn add2(x: i32, y: i32) -> i32 {
    // Implicit return (no semicolon)
    x + y
}

#[allow(unused_variables)]
#[allow(unused_assignments)]
#[allow(dead_code)]
// Main function
fn main() {
    // Numbers //

    // Immutable bindings
    let x: i32 = 1;

    // Integer/float suffixes
    let y: i32 = 13i32;
    let f: f64 = 1.3f64;

    // Type inference
    // Most of the time, the Rust compiler can infer what type a variable is, so
    // you don’t have to write an explicit type annotation.
    // Throughout this tutorial, types are explicitly annotated in many places,
    // but only for demonstrative purposes. Type inference can handle this for
    // you most of the time.
    let implicit_x = 1;
    let implicit_f = 1.3;

    // Arithmetic
    let sum = x + y + 13;

    // Mutable variable
    let mut mutable = 1;
    mutable = 4;
    mutable += 2;

    // Strings //

    // String literals
    let x: &str = "hello world!";

    // Printing
    println!("{} {}", f, x); // 1.3 hello world

    // A `String` – a heap-allocated string
    // Stored as a `Vec<u8>` and always hold a valid UTF-8 sequence, 
    // which is not null terminated.
    let s: String = "hello world".to_string();

    // A string slice – an immutable view into another string
    // This is basically an immutable pair of pointers to a string – it doesn’t
    // actually contain the contents of a string, just a pointer to
    // the begin and a pointer to the end of a string buffer,
    // statically allocated or contained in another object (in this case, `s`).
    // The string slice is like a view `&[u8]` into `Vec<T>`.
    let s_slice: &str = &s;

    println!("{} {}", s, s_slice); // hello world hello world

    // Vectors/arrays //

    // A fixed-size array
    let four_ints: [i32; 4] = [1, 2, 3, 4];

    // A dynamic array (vector)
    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
    vector.push(5);

    // A slice – an immutable view into a vector or array
    // This is much like a string slice, but for vectors
    let slice: &[i32] = &vector;

    // Use `{:?}` to print something debug-style
    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

    // Tuples //

    // A tuple is a fixed-size set of values of possibly different types
    let x: (i32, &str, f64) = (1, "hello", 3.4);

    // Destructuring `let`
    let (a, b, c) = x;
    println!("{} {} {}", a, b, c); // 1 hello 3.4

    // Indexing
    println!("{}", x.1); // hello

    //////////////
    // 2. Types //
    //////////////

    // Struct
    struct Point {
        x: i32,
        y: i32,
    }

    let origin: Point = Point { x: 0, y: 0 };

    // A struct with unnamed fields, called a ‘tuple struct’
    struct Point2(i32, i32);

    let origin2 = Point2(0, 0);

    // Basic C-like enum
    enum Direction {
        Left,
        Right,
        Up,
        Down,
    }

    let up = Direction::Up;

    // Enum with fields
    enum OptionalI32 {
        AnI32(i32),
        Nothing,
    }

    let two: OptionalI32 = OptionalI32::AnI32(2);
    let nothing = OptionalI32::Nothing;

    // Generics //

    struct Foo<T> { bar: T }

    // This is defined in the standard library as `Option`
    enum Optional<T> {
        SomeVal(T),
        NoVal,
    }

    // Methods //

    impl<T> Foo<T> {
        // Methods take an explicit `self` parameter
        fn bar(&self) -> &T { // self is borrowed
            &self.bar
        }
        fn bar_mut(&mut self) -> &mut T { // self is mutably borrowed
            &mut self.bar
        }
        fn into_bar(self) -> T { // here self is consumed
            self.bar
        }
    }

    let a_foo = Foo { bar: 1 };
    println!("{}", a_foo.bar()); // 1

    // Traits (known as interfaces or typeclasses in other languages) //

    trait Frobnicate<T> {
        fn frobnicate(self) -> Option<T>;
    }

    impl<T> Frobnicate<T> for Foo<T> {
        fn frobnicate(self) -> Option<T> {
            Some(self.bar)
        }
    }

    let another_foo = Foo { bar: 1 };
    println!("{:?}", another_foo.frobnicate()); // Some(1)

    // Function pointer types // 

    fn fibonacci(n: u32) -> u32 {
        match n {
            0 => 1,
            1 => 1,
            _ => fibonacci(n - 1) + fibonacci(n - 2),
        }
    }

    type FunctionPointer = fn(u32) -> u32;

    let fib : FunctionPointer = fibonacci;
    println!("Fib: {}", fib(4)); // 5

    /////////////////////////
    // 3. Pattern matching //
    /////////////////////////

    let foo = OptionalI32::AnI32(1);
    match foo {
        OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),
        OptionalI32::Nothing  => println!("it’s nothing!"),
    }

    // Advanced pattern matching
    struct FooBar { x: i32, y: OptionalI32 }
    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };

    match bar {
        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
            println!("The numbers are zero!"),
        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
            println!("The numbers are the same"),
        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
            println!("Different numbers: {} {}", n, m),
        FooBar { x: _, y: OptionalI32::Nothing } =>
            println!("The second number is Nothing!"),
    }

    /////////////////////
    // 4. Control flow //
    /////////////////////

    // `for` loops/iteration
    let array = [1, 2, 3];
    for i in array {
        println!("{}", i);
    }

    // Ranges
    for i in 0u32..10 {
        print!("{} ", i);
    }
    println!("");
    // prints `0 1 2 3 4 5 6 7 8 9 `

    // `if`
    if 1 == 1 {
        println!("Maths is working!");
    } else {
        println!("Oh no...");
    }

    // `if` as expression
    let value = if true {
        "good"
    } else {
        "bad"
    };

    // `while` loop
    while 1 == 1 {
        println!("The universe is operating normally.");
        // break statement gets out of the while loop.
        //  It avoids useless iterations.
        break
    }

    // Infinite loop
    loop {
        println!("Hello!");
        // break statement gets out of the loop
        break
    }

    /////////////////////////////////
    // 5. Memory safety & pointers //
    /////////////////////////////////

    // Owned pointer – only one thing can ‘own’ this pointer at a time
    // This means that when the `Box` leaves its scope, it can be automatically deallocated safely.
    let mut mine: Box<i32> = Box::new(3);
    *mine = 5; // dereference
    // Here, `now_its_mine` takes ownership of `mine`. In other words, `mine` is moved.
    let mut now_its_mine = mine;
    *now_its_mine += 2;

    println!("{}", now_its_mine); // 7
    // println!("{}", mine); // this would not compile because `now_its_mine` now owns the pointer

    // Reference – an immutable pointer that refers to other data
    // When a reference is taken to a value, we say that the value has been ‘borrowed’.
    // While a value is borrowed immutably, it cannot be mutated or moved.
    // A borrow is active until the last use of the borrowing variable.
    let mut var = 4;
    var = 3;
    let ref_var: &i32 = &var;

    println!("{}", var); // Unlike `mine`, `var` can still be used
    println!("{}", *ref_var);
    // var = 5; // this would not compile because `var` is borrowed
    // *ref_var = 6; // this would not either, because `ref_var` is an immutable reference
    ref_var; // no-op, but counts as a use and keeps the borrow active
    var = 2; // ref_var is no longer used after the line above, so the borrow has ended

    // Mutable reference
    // While a value is mutably borrowed, it cannot be accessed at all.
    let mut var2 = 4;
    let ref_var2: &mut i32 = &mut var2;
    *ref_var2 += 2;         // '*' is used to point to the mutably borrowed var2

    println!("{}", *ref_var2); // 6 , // var2 would not compile.
    // ref_var2 is of type &mut i32, so stores a reference to an i32, not the value.
    // var2 = 2; // this would not compile because `var2` is borrowed.
    ref_var2; // no-op, but counts as a use and keeps the borrow active until here
}

//댓글입니다. 줄 주석은 다음과 같습니다... 
// 이렇게 여러 줄을 확장합니다.

/* 블록 주석 
  /* 중첩될 수 있습니다. */ */

/// 문서 주석은 다음과 같으며 마크다운 표기법을 지원합니다. 
/// # 예 
/// 
/// ``` 
/// let five = 5 
/// ```

/////////////// 
// 1. 기본 // 
///////////////

#[허용(dead_code)]
// 함수 
// `i32`는 32비트 부호 있는 정수에 대한 유형입니다. 
fn  add2 ( x : i32 , y : i32 ) -> i32 {   
    // 암시적 반환(세미콜론 없음) 
x + y      
}

#[허용(unused_variables)]
#[허용(미사용_할당)]
#[허용(dead_code)]
// 주요 함수 
fn  main () { 
    // 숫자 //

    // 불변 바인딩 
let x : i32 = 1 ;       

    // 정수/부동 소수점 접미사 
let y : i32 = 13 i32 ;       
    f : f64 = 1.3 f64 ; _   

    // 유형 추론 
// 대부분의 경우 Rust 컴파일러는 변수의 유형을 추론할 수 있으므로 // 명시적인 유형 주석을 작성할 필요가 없습니다. // 이 튜토리얼 전반에 걸쳐 여러 위치에서 유형에 명시적으로 주석이 달렸 지만 // 이는 설명 목적으로만 사용되었습니다. 유형 추론은 대부분의 경우 // 이를 처리할 수 있습니다 . implicit_x = 1 로 설정 ;    
    
    
    
    
       
    implicit_f = 1.3 ; _   

    // 산술 
let sum = x + y + 13 ;           

    // 가변 변수 
let mut mutable = 1 ;        
    변경 가능 = 4 ;  
    변경 가능 += 2 ;  

    // 문자열 //

    // 문자열 리터럴 
let x : & str = "hello world!" ;       

    // 인쇄 
println ! ( "{} {}" , f , x ); // 1.3 안녕하세요 세계       

    // `String` - 힙에 할당된 문자열 
// `Vec<u8>`로 저장되며 항상 유효한 UTF-8 시퀀스를 보유하며 // 이는 null로 끝나지 않습니다. let s : String = "hello world" . to_string ();    
    
       

    // 문자열 슬라이스 – 다른 문자열에 대한 불변의 뷰 
// 이것은 기본적으로 문자열에 대한 불변의 포인터 쌍입니다. // 실제로는 문자열의 내용을 포함 하지 않으며 // 시작과 문자열 에 대한 포인터만 포함합니다. 문자열 버퍼의 끝을 가리키는 포인터, // 정적으로 할당되거나 다른 개체(이 경우 `s`)에 포함됩니다. // 문자열 슬라이스는 `Vec<T>`에 대한 `&[u8]` 뷰와 같습니다. s_slice를 보자 : & str = & s ;    
    
    
    
    
       

    인쇄하다 ! ( "{} {}" , s , s_slice ); //안녕하세요 세상안녕세상   

    // 벡터/배열 //

    // 고정 크기 배열 
let four_ints : [ i32 ; 4 ] = [ 1 , 2 , 3 , 4 ];           

    // 동적 배열(벡터) 
let mut 벡터 : Vec < i32 > = vec ! [ 1 , 2 , 3 , 4 ];           
    벡터입니다 . 푸시 ( 5 );

    // 슬라이스 – 벡터 또는 배열에 대한 불변 뷰 
// 이는 문자열 슬라이스와 매우 유사하지만 벡터의 경우 let Slice : & [ i32 ] = & vector ;    
       

    // 디버그 스타일로 뭔가를 인쇄하려면 `{:?}`를 사용하세요. 
println ! ( "{:?} {:?}" , 벡터 , 슬라이스 ); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]       

    // 튜플 //

    // 튜플은 다양한 유형의 값으로 구성된 고정 크기 집합입니다. 
let x : ( i32 , & str , f64 ) = ( 1 , "hello" , 3.4 );           

    // `let` 구조 분해 
let ( a , b , c ) = x ;         
    인쇄하다 ! ( "{} {} {}" , a , b , c ); // 1 안녕하세요 3.4    

    // 
println 인덱싱 ! ( "{}" , x . 1 ); // 안녕하세요      

    ////////////// 
// 2. 유형 ///////////////    
    

    // 구조체 
구조체 포인트 {      
        x : i32 ,
        y : i32 ,
    }

    원점 설정 : 점 = 점 { x : 0 , y : 0 } ;       

    // 'tuple struct'라고 불리는 명명되지 않은 필드가 있는 구조체 
struct Point2 ( i32 , i32 );      

    원점2 = Point2 ( 0,0 ) 로 둡니다 .    

    // 기본 C와 유사한 열거형 
열거 형 방향 {      
        왼쪽 ,
        오른쪽 ,
        위로 ,
        아래에 ,
    }

    let up = 방향 :: 위로 ;   

    // 필드가 있는 열거 
형 enum OptionalI32 {      
        AnI32 ( i32 ),
        아무것도 아님 ,
    }

    두 가지 : OptionalI32 = OptionalI32 :: AnI32 ( 2 ) ;   
    let Nothing = OptionalI32 :: 아무것도 ;   

    // 제네릭 //

    struct  Foo < T > { 바 : T }   

    // 이는 표준 라이브러리에 `Option`으로 정의되어 있습니다. 
enum Optional < T > {      
        SomeVal ( T ),
        노발 ,
    }

    // 메소드 //

    impl < T > 푸 < T > {  
        // 메소드는 명시적인 `self` 매개변수를 사용합니다. 
fn bar ( & self ) -> & T { // self 는 빌려왔습니다 & self . 술집            
            
        }
        fn  bar_mut ( & mut self ) -> & mut T { // self는 가변적으로 빌릴 수 있습니다 & mut self . 술집     
             
        }
        fn  into_bar ( self )  -> T { // 여기서 self 는 소비됩니다 self . 술집  
            
        }
    }

    let a_foo = Foo { bar : 1 };      
    인쇄하다 ! ( "{}" , a_foo . bar ()); // 1  

    // 특성(다른 언어에서는 인터페이스 또는 타입클래스라고 함) //

    특성 Frobnicate < T > {  
        fn  frobnicate ( self )  -> 옵션 < T > ;
    }

    impl < T > Foo < T > { 에 대한 Frobnicate < T >    
        fn  frobnicate ( self )  -> 옵션 < T > { 
            일부 ( self .bar ) _
        }
    }

    let another_foo = Foo { bar : 1 };      
    인쇄하다 ! ( "{:?}" , another_foo . frobnicate ()); // 일부(1)  

    // 함수 포인터 유형 //

    fn  피보나치 ( n : u32 )  -> u32  {
        일치 하는 {  
            0 => 1 ,  
            1 => 1 ,  
            _ => 피보나치 ( n - 1 ) + 피보나치 ( n - 2 ),        
        }
    }

    유형  FunctionPointer = fn ( u32 ) -> u32 ;   

    let fib : FunctionPointer = fibonacci ;    
    인쇄하다 ! ( "Fib: {}" , fib ( 4 )); // 5  

    //////////////////////// 
// 3. 패턴 매칭 // ////////////////// ////////    
    

    let foo = OptionalI32 :: AnI32 ( 1 );   
    일치하는 foo {  
        OptionalI32 :: AnI32 ( n ) => println ! ( "i32입니다: {}" , n ),   
        OptionalI32 :: 아무것도 => println ! ( "아무것도 아니야!" ),   
    }

    // 고급 패턴 매칭 
struct FooBar { x : i32 , y : OptionalI32 }         
    let bar = FooBar { x : 15 , y : OptionalI32 :: AnI32 ( 32 ) };       

    매치 바 {  
        FooBar { x : 0 , y : OptionalI32 :: AnI32 ( 0 ) } =>     
            인쇄하다 ! ( "숫자는 0입니다!" ),
        FooBar { x : n , y : OptionalI32 :: AnI32 ( m ) } if n == m =>         
            인쇄하다 ! ( "숫자는 같습니다" ),
        FooBar { x : n , y : OptionalI32 :: AnI32 ( m ) } =>     
            인쇄하다 ! ( "다른 숫자: {} {}" , n , m ),  
        FooBar { x : _ , y : OptionalI32 :: 없음 } =>     
            인쇄하다 ! ( "두 번째 숫자는 아무것도 아닙니다!" ),
    }

    ///////////////////// 
// 4. 제어 흐름 //////////////////////    
    

    // `for` 루프/반복 
let array = [ 1 , 2 , 3 ];         
    배열 의 i 에 대해 {    
        인쇄하다 ! ( "{}" , 나 ); 
    }

    // 
0 u32 .. 10 { 의 i 범위        
        인쇄 ! ( "{} " , 나 ); 
    }
    인쇄하다 ! ( "" );
    // `0 1 2 3 4 5 6 7 8 9`를 인쇄합니다.

    // `if` 
if 1 == 1 {        
        인쇄하다 ! ( "수학이 효과가 있어요!" );
    } 또 다른 {  
        인쇄하다 ! ( "안 돼..." );
    }

    // `if` 표현식 
let value = if true {         
        "좋은"
    } 또 다른 {  
        "나쁜"
    };

    // `while` 루프 
while 1 == 1 {        
        인쇄하다 ! ( "우주는 정상적으로 작동하고 있습니다." );
        // break 문은 while 루프에서 벗어납니다. 
// 쓸모없는 반복을 방지합니다. 부서지다        
        
    }

    // 무한 루프 
루프 {     
        인쇄하다 ! ( "안녕하세요!" );
        
// break문은 루프 에서 빠져나옵니다.        
    }

    /////////////////////////////// 
// 5. 메모리 안전성 및 포인터 // /////// ///////////////////////////    
    

    // 소유 포인터 - 한 번에 한 가지만 이 포인터를 '소유'할 수 있습니다. 
// 이는 `Box`가 해당 범위를 벗어날 때 자동으로 안전하게 할당이 해제될 수 있음을 의미합니다. let mutmine : Box < i32 > = Box :: new ( 3 ) ;    
        
    * 광산 = 5 ; // 역참조 // 여기서 `now_its_mine`은 `mine`의 소유권을 갖습니다. 즉, '내 것'이 옮겨진 것이다. mut now_its_mine = 광산을 보자 ;   
    
        
    * now_its_mine += 2 ;  

    인쇄하다 ! ( "{}" , now_its_mine ); // 7 // println!("{}", 광산); // 이제 `now_its_mine`이 포인터를 소유하므로 컴파일되지 않습니다.  
    

    // 참조 - 다른 데이터를 참조하는 불변 포인터 
// 값에 대한 참조가 취해지면 해당 값이 '빌려졌다'고 말합니다. // 값은 불변적으로 빌릴 수 있지만 변경하거나 이동할 수는 없습니다. // 차용 변수를 마지막으로 사용할 때까지 차용이 활성화됩니다. mut var = 4 로 설정하세요 ;    
    
    
        
    변수 = 3 ;  
    let ref_var : & i32 = & var ;   

    인쇄하다 ! ( "{}" , var ); // `mine`과 달리 `var`은 여전히 ​​사용할 수 있습니다. println ! ( "{}" , * ref_var );  
     
    // var = 5; // `var`을 차용했기 때문에 컴파일되지 않습니다. 
// *ref_var = 6; // `ref_var`은 불변 참조이므로 이 역시 마찬가지입니다. ref_var ; // 작동하지 않지만 사용으로 간주되어 빌림을 활성 상태로 유지합니다. var = 2 ; // 위 줄 이후에는 ref_var가 더 이상 사용되지 않으므로 빌림이 종료되었습니다.    
     
       

    // 가변 참조 
// 값을 가변적으로 빌려오는 동안에는 전혀 접근할 수 없습니다. mut var2 = 4 로 설정하세요 ;    
        
    let ref_var2 : & mut i32 = & mut var2 ;     
    * ref_var2 += 2 ; // '*'는 변경 가능하게 빌린 var2를 가리키는 데 사용됩니다.           

    인쇄하다 ! ( "{}" , * ref_var2 ); // 6 , // var2는 컴파일되지 않습니다. // ref_var2는 &mut i32 유형이므로 값이 아닌 i32에 대한 참조를 저장합니다. // var2 = 2; // `var2`를 빌려왔기 때문에 컴파일되지 않습니다. ref_var2 ; // 작동하지 않지만 사용으로 간주되어 여기까지 빌림을 활성 상태로 유지합니다. }