fn main()

• fn => function notation
• main() => declaring a main function

comment

-line comment
//

-block comment
/*...*/

-doc comment
	-outer doc comment
	///
    : 코드블록 외부에 작성되고 markdown표기법을 지원
    
    -inner doc comment
    //!
    : 코드블록 내의 항목을 참조하는 문서를 생성하는데 사용됨 

compile

let x = 10; //컴파일시 warning 
//warning 문구 안보고 싶으면 '_' 추가 
let _x = 10; //이라고 적으면 됨 

casting

casting = simple type change using 'as'
---------------------------------------

let my_number = 8; //i32
let second_number: u8 = 10;
let third_number = my_number + second_number as u16;

print!("my third number is {}", third_number);

fn main() {
	let my_number = 'a' as u8;
    print!("my_number is {}" my_number); // 97 = decimal
}

macro

• macro = function that wirtes
• macro = 괄호앞에 !가 있는 표현식 // !(); ex) println!();

print line

fn give_age() -> i32 {
    25
}

fn main() {
    let my_name = "Joe";
    // let my_age = 25;
    println!("My name is {} and my age is {}", my_name, give_age());
    println!("My name is {my_name}");
}

fn main() {
    let city = "Seoul";
    let city2 = "Busan";
    let city3 = "Incheon";
    
    let year = 2002;
    let year2 = 2020;
    let year3 = 2023;
    
    println!("The city of {} in {} is good", city, year);
    println!("The city of {0} in {1} is good", city2, year2);
    println!("The city of {city3} in {year3} is good");
}

1. printing styles

print!() : 단순히 출력값을 콘솔에 보여줌
println!() : 출력값 끝에 줄바꿈 
eprint!() : 출력을 오류로 표시 
eprintln!() : 출력을 오류로 표시하고 줄바꿈

placeholder traits

• 2진수 16진수 8진수로 변환가능

fn main() {
    println!("Number : 10 \nBinary:{:b} Hexadecimal:{:x} Octal:{:o}", 10, 10, 10);
}
//Number : 10 
  Binary:1010 Hexadecimal:a Octal:12

variables

• 연결된 이름은 식별자이고 변수 내부에 들어가는 데이터는 값
  let variable_name = "data" ;

• 기본적으로 변경할 수 없음(immutable by default) 따라서 재할당도 불가능

1. mut

• 변수를 변경 가능하게 해주는 keyword

fn main() {
    let mut language = "Rust"; 
    println!("Language: {}", language); 
    
    language = "Java"; 
    println!("Language: {}", language); 
}

2. Assigning Multiple Variables

• one statement 에 여러 변수 할당할 수 있음

fn main() {
    let (course,category) = ("Rust","beginner"); 
    println!("This is a {} course in {}.", category, course); 
}

scope

• 변수가 선언되는 위치에 따라 참조할 수 있는 범위가 다름
• {...}내부에 선언된 경우 범위는 중괄호 내에서 제한, 그렇지 않은경우 범위는 코드 전체

1. type of variable

local varibale (지역변수)

• 코드블록 외부에서 접근 할 수 없는 변수
• {...}안에 있는 변수는 지역변수

gllbal variable (전역변수)

• 코드블록 외부에서 선언되고 아무 블록에서 접근 할 수 있는 변수

note : const키워드를 사용해 선언된 변수는
지역변수 뿐만 아니라 전역변수로도 선언될 수 있다.

2. shadowing

• shadowing은 특정 범위 내에서 선언된 변수가 외부 범위에서 선언된 변수와 동일한 이름을 갖는 기술
• 외부 변수는 내부 변수에 의해 가려진다
• 내부 변수는 외부 변수를 가린다

fn main() {
  let outer_variable = 100;
  
  { // start of code block
        let inner_variable = 200;
        println!("block variable: {}", inner_variable);
        let outer_variable = 300;
        println!("block variable outer: {}", outer_variable);
  } // end of code block
  
    println!("outer variable: {}", outer_variable);
  }
  ---------------------------------------------------------------
  *console
  block variable: 200
  block variable outer: 300
  outer variable: 100

data types

• rust에서는 두가지 방법으로 변수를 정의할 수 있다.

1. Implicit Definition (암시적 정의)
   let variable name = value;
   rust는 변수에 할당된 값의 타입으로부터 타입을 추론할 수 있다.

2. Explicit Definition (명시적 정의)
   let variable name : datatype = value;
   변수 타입에 대해 명시적으로 작성한다.

primitive types

1. scalar types

• integers
• floats
• boolean
• character/char

1-1. integers

+ : plus sign
- : minus sign

isize : i8, i16, i32, i64, i128 - signed Interger
usize : u8, u16, u32, u64, u128 - Unsigned 

• 타입을 따로 적어주지 않으면 i32가 default 값으로 설정됨

// type inference

let my_number : u8 = 100;
let my_other_number = 200;

let third_number = my_number + my_other_number; //u8 + i32는 불가능
error : mismatched types

1-2. floats

• f32 / f64

fn main() {
    let my_num = 9.5; //f64
    let other_number = 9; // i32
    println!("{}", my_num as i32 + other_number); // 18
    println!("{}", my_num + other_number as f32); // 18.5
}

1-3. char

string = ""
char = ''

------------------------
let first_letter = 'A';
let space = ' ';
let other_language_char = '가';
let cat_face = '😺';

• 모든 char 크기는 4byte

2. compound types

• array
• tuple

2-1. array

array of size = 4
1, 2, 3, 4 <= value 
----------
0, 1, 2, 3 <= index

• array를 선언하기위해 type과 array의 size를 정의해주어야 한다
  

fn main() {
   //define an array of size 4
   let arr:[i32;4] = [1, 2, 3, 4]; 
   
   // initialize an array of size 4 with 
   let arr1 = [0 ; 4]; 
   print!("{}"arr);
}

note
기본적으로 배열은 변경할 수 없다

• 배열 특정요소에 접근하는 방법

  [ ]을 사용

  fn main() {
  	let arr:[i32;4] = [1, 2, 3, 4];
      println!("The first value of array is {}", arr[0]);
    
      let arr1 = [0; 4]; 
      println!("The first value of array is {}", arr1[1]);
  }
  

• 배열의 값 변경하는 방법 (재할당)

  let뒤에 mut keyword를 사용해서 선언한다.

  fn main() {
     let mut arr:[i32;4] = [1, 2, 3, 4]; 
     println!("The value of array at index 1: {}", arr[1]);
     
     arr[1] = 9;
     println!("The value of array at index 1: {}", arr[1]);
  }
  

• 배열의 길이 구하는 법

  use the built-in function len (내장함수 len 이용)

  fn main() {
    let arr:[i32;4] = [1, 2, 3, 4]; 
    
    // print the length of array
    println!("Length of array: {}", arr.len());
   }

• 배열 출력하는 법

  The whole array can be traversed using a loop or the debug trait.

• slice

  slice는 두 단어로 구성된 객체이며, 첫 번째 단어는 data pinter, 두 번째 단어는 slice length

2-2 tuples

• Tuples are heterogeneous sequences of elements (서로 다른 요소들의 모임)

• 배열과 마찬가지 튜플의 길이는 고정

• syntax 1 (타입지정 x)
  

• syntax 2 (타입 지정 o)
  

• 특정 값에 접근하는 법

1. .(dot operator)을 사용해서 접근 가능
2. 구조분해로 접근 가능

fn main() {
let person_data = ("Joe", 25, "75kg", "8ft");
let (a,b,c,d) = person_data;

println!("name : {}", person_data.0); 
println!("name : {}", person_data.1);

println!("weight : {}", c);
println!("height : {}", d);
}

• 튜플 값 변경하는 방법 (재할당)

  mutkeyword로 접근가능

fn main() {
    let mut person_data = ("Joe", 25, "75kg", "8ft");

    println!(index 0 and index 1 are {} {}", person_data.0, person_data.1);

    person_data.0 = "John";

    println!("index 0 and index 1 are {} {}", person_data.0, person_data.1);
}

• 튜플 출력하는 법

  The whole tuple can be traversed using the debug trait.

fn main() {
    //define a tuple
    let person_data = ("Joe", 25, "75kg", "8ft");
    
    //print the value of tuple
    println!("Tuple - Person Data : {:?}", person_data);
}

constant variables

• constant variable : 프로그램 범위 전체에서 상수로 선언되는 변수
  값을 수정할 수 없다
  global 및 local 범위에서 정의할 수 있다.]

1. syntax

• 선언
  const(keyword) + 변수 이름 + 콜론: + 변수의 데이터 타입
  

• note
  모든 문자는 대문자
  모든 단어는 underscore_을 사용해서 구분해야함

2. scope

const ID_1: i32 = 4; // define a global constant variable

fn main() {
    const ID_2: u32 = 3; // define a local constant variable
    
    println!("ID:{}", ID_1); // print the global constant variable
    println!("ID:{}", ID_2); // print the local constant variable
}

3. const Vs let

3-1 declaration

• 상수는const로 선언

3-2 scope

• const 상수는 global 및 local로 선언됨
• let 변수는 local로 선언됨

3-3 mutability

• const는 변경 불가능
• let은 mut으로 변경 가능

3-4 data type

• const의 타입 명시는 필수
• let 필수는 아님

3-5 set value at run-time

const는 프로그램 실행전에만 설정가능
let은 런타임중에도 결과 저장가능

3-6 shadowing

let과 달리 const는 숨길 수 없음