바이브코딩만 해봤어도, 이 정도면 읽고 쓸 수 있습니다

let x = 5;                    // 불변(기본값) — 재할당하면 에러
let mut y = 10;                // mut 없으면 가변 불가
y = 20;

let name: &str = "won";       // 타입은 보통 추론, 명시도 가능
const MAX: u32 = 100;          // const는 타입 명시 필수

let x = 5;                     // 재할당 가능 (기본)
const y = 10;                  // 재할당 불가 — 실무 기본값
let name: string = "won";
const MAX: number = 100;

fn add(a: i32, b: i32) -> i32 {
    a + b   // 세미콜론 없으면 이 줄이 곧 반환값
}

fn greet(name: &str) {
    println!("hello, {}", name);
}

function add(a: number, b: number): number {
    return a + b;   // return 필수
}

const greet = (name: string): void => {
    console.log(`hello, ${name}`);
};

struct User {
    name: String,
    age: u32,
}

impl User {
    fn greet(&self) -> String {
        format!("hi, {}", self.name)
    }
}

let u = User { name: "won".to_string(), age: 20 };
println!("{}", u.greet());

interface User {
    name: string;
    age: number;
}

function greet(u: User): string {
    return `hi, ${u.name}`;
}

const u: User = { name: "won", age: 20 };
console.log(greet(u));

enum Status {
    Loading,
    Success(String),        // variant마다 다른 데이터를 담음
    Error { code: u32 },
}

let s = Status::Success("done".to_string());

match s {
    Status::Loading => println!("loading"),
    Status::Success(msg) => println!("ok: {}", msg),
    Status::Error { code } => println!("err {}", code),
}

type Status =
    | { kind: "loading" }
    | { kind: "success"; msg: string }
    | { kind: "error"; code: number };

const s: Status = { kind: "success", msg: "done" };

switch (s.kind) {
    case "loading": console.log("loading"); break;
    case "success": console.log(`ok: ${s.msg}`); break;
    case "error": console.log(`err ${s.code}`); break;
}

let n = 7;

if n % 2 == 0 {
    println!("even");
} else {
    println!("odd");
}

let label = match n {
    0 => "zero",
    1..=9 => "single digit",   // 범위 매칭
    _ => "big",                  // _ 는 default
};

const n = 7;

if (n % 2 === 0) {
    console.log("even");
} else {
    console.log("odd");
}

const label =
    n === 0 ? "zero" :
    n < 10 ? "single digit" :
    "big";

for i in 0..5 {                // 0,1,2,3,4 (5는 미포함)
    println!("{}", i);
}

let v = vec![1, 2, 3];
for x in &v {                    // 참조로 순회 — v는 여전히 살아있음
    println!("{}", x);
}

let mut i = 0;
while i < 3 {
    i += 1;
}

for (let i = 0; i < 5; i++) {
    console.log(i);
}

const v = [1, 2, 3];
for (const x of v) {
    console.log(x);
}

let i = 0;
while (i < 3) {
    i++;
}

let mut v: Vec<i32> = vec![1, 2, 3];
v.push(4);

let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
let evens: Vec<&i32> = v.iter().filter(|x| *x % 2 == 0).collect();

use std::collections::HashMap;
let mut m: HashMap<String, i32> = HashMap::new();
m.insert("a".to_string(), 1);

const v: number[] = [1, 2, 3];
v.push(4);

const doubled: number[] = v.map((x) => x * 2);
const evens: number[] = v.filter((x) => x % 2 === 0);

const m = new Map<string, number>();
m.set("a", 1);

fn find(v: &[i32], target: i32) -> Option<usize> {
    for (i, x) in v.iter().enumerate() {
        if *x == target { return Some(i); }
    }
    None
}

match find(&[1, 2, 3], 2) {
    Some(i) => println!("found at {}", i),
    None => println!("not found"),
}

fn parse(s: &str) -> Result<i32, String> {
    s.parse::<i32>().map_err(|_| "bad number".to_string())
}

let n = parse("42")?;   // ? 는 에러면 즉시 함수 리턴

function find(v: number[], target: number): number | undefined {
    const i = v.indexOf(target);
    return i === -1 ? undefined : i;
}

const i = find([1, 2, 3], 2);
if (i !== undefined) console.log(`found at ${i}`);

function parse(s: string): number {
    const n = Number(s);
    if (Number.isNaN(n)) throw new Error("bad number");
    return n;
}

try {
    const n = parse("42");
} catch (e) {
    console.error(e);
}

let add_one = |x: i32| x + 1;
println!("{}", add_one(4));

let factor = 3;
let scale = |x: i32| x * factor;   // 바깥 변수를 자동으로 캡처

const addOne = (x: number) => x + 1;
console.log(addOne(4));

const factor = 3;
const scale = (x: number) => x * factor;  // 마찬가지로 자동 캡처

trait Greet {
    fn greet(&self) -> String;
}

struct Dog;

impl Greet for Dog {
    fn greet(&self) -> String {
        "woof".to_string()
    }
}

fn say_hi(g: &impl Greet) {   // 트레이트를 만족하는 아무 타입이나
    println!("{}", g.greet());
}

interface Greet {
    greet(): string;
}

class Dog implements Greet {
    greet(): string {
        return "woof";
    }
}

function sayHi(g: Greet): void {
    console.log(g.greet());
}

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in list {
        if item > max { max = item; }
    }
    max
}

let nums = vec![3, 7, 2];
println!("{}", largest(&nums));

function largest<T>(list: T[]): T {
    let max = list[0];
    for (const item of list) {
        if (item > max) max = item;
    }
    return max;
}

const nums = [3, 7, 2];
console.log(largest(nums));

// String은 힙에 저장되는 소유 타입 — 정수 같은 Copy 타입은 이 규칙에서 열외
let s1 = String::from("hello");
let s2 = s1;                     // s1의 소유권이 s2로 "이동"(move) — s1은 이제 못 씀
// println!("{}", s1);      // 컴파일 에러!

fn print_len(s: &String) {        // &로 "빌려오기"(borrow) — 소유권은 호출자 것 그대로
    println!("{}", s.len());
}
print_len(&s2);                     // s2는 여전히 살아있음

fn add_world(s: &mut String) {     // &mut 로 가변 빌림 — 값을 바꿀 수 있음
    s.push_str(" world");
}

async fn fetch_name() -> String {
    "won".to_string()
}

#[tokio::main]
async fn main() {
    let name = fetch_name().await;
    println!("{}", name);
}

async function fetchName(): Promise<string> {
    return "won";
}

async function main() {
    const name = await fetchName();
    console.log(name);
}

main();

let name = "won";
let age = 20;
println!("{} is {} years old", name, age);
println!("{name} is {age} years old"); // 이름 있는 캡처(최신 문법)
let s = format!("{}-{}", name, age);       // 문자열로 "만들기"만, 출력은 안 함

const name = "won";
const age = 20;
console.log(`${name} is ${age} years old`);
const s = `${name}-${age}`;