9가지 프로그래밍 언어로 배우는 개념: 1편 - 타입 이론

// Java 코드
public class Person {
  public String name;
  public String nickname;
}
Person person = new Person();
person.name = "Min Gyu Chi";
person.nickname = null; // 별명은 없다

// Java 코드
Integer a = null;
Integer b = a + a; // null 더하기 null은 어떤 값이지? NullPointerException 에러!

// Java 코드
public class Person {
  public String name;
  @Nullable public String nickname; // 이 필드는 null이 들어갈 수도 있어
}

// Java 코드
Optional<String> nickname = Optional.empty();

// Rust 코드
let nickname: Option<String> = None;

// Scala 코드
val nickname: Option[String] = None;

// C# 코드
String? nickname = null;

// Kotlin 코드
val nickname: String? = null;

// Java 코드
public class Optional<T> {
  private final T value; // 필드 하나 그대로 null인지 아닌지 확인
  /* ... */
}

// C# 코드
// 레퍼런스 타입이 아닌 경우
public struct Nullable<T> {
  private bool hasValue; // null인지 저장하는 필드
  private T value;
  /* ... */
}

// 레퍼런스 타입인 경우
String? nickname; // 컴파일 타임에 모든 체크가 강제된다

// Kotlin 코드
val nickname: String?; // 컴파일 타임에 모든 체크가 강제된다

// Rust 코드
pub enum Option<T> { // Option<T> 이라는 타입이 있는데
  None,           // None 이거나
  Some(T)         // T를 가진 Some 이거나
}

// Scala 코드
sealed trait Option[+A]                         // Option[A] 이라는 타입이 있는데
case object None extends Option[Nothing]        // None 이거나
case class Some[+A](value: A) extends Option[A] // A를 가진 Some 이거나

// Typescript 코드
let nickname: string | null; // string 일 수도 있고 null 일 수도 있어

// C/C++ 코드
struct Human {
  string name;
  int age;
}

// Rust 코드
pub struct Human {
  name: String,
  age: i32,
}

// Kotlin 코드
data class Human(val name: String, val age: Int)

// Scala 코드
case class Human(name: String, age: Int)

// Typescript 코드
const nickname1: string | null = 'mango'; // mango라는 별명도 있을 수 있고
const nickname2: string | null = 'mystery meat'; // mystery meat도 있을 수 있고
const nickname3: string | null = null; // 별명이 없을 수도 있지

// Typescript 코드
type CouponCode = string | number        // 쿠폰 번호는 문자열이거나 숫자
type ExcelCell = string | number | Date  // 엑셀 셀은 문자열, 숫자, 시간 중 하나

// Rust 코드
pub enum CouponCode {
  CouponString(String),
  CouponNumber(i32),
}

// Scala 코드
sealed trait CouponCode
case class CouponString(value: String) extends CouponCode
case class CouponNumber(value: Int) extends CouponCode

// Java 코드
public abstract class Job {
  public int speedLevel; // speed level은 공유한다
}

public class Police extends Job {
  public int strengthLevel;
  public int fame;
}

public class Robber extends Job {
  public int robberyLevel;
  public int infamy;
}

public class Human {
  public String name;
  public int health;
  public Job job;
}

// Java 코드
public abstract class Job {
  public int speedLevel;

  // 어느 정보가 어디서 왔는지 모른다!
  public abstract Optional<Int> getStrengthLevel();
  public abstract Optional<Int> getRobberyLevel();
  public Int getSpeedLevel() {
    return Optional.of(speedLevel);
  }
  public abstract Optional<Int> getFame();
  public abstract Optional<Int> getInfamy();
}

// Java 코드
public int getScore(Job job) {
  if (job instanceof Police) {
    return ((Police) job).fame * 100;
  } else if (job instanceof Robber) {
    return ((Robber) job).infamy * 150;
  } else {
    // 이 경우는 불가능하니까 exception을 던진다?
    throw new RuntimeException("Unreachable code");
  }
}

// Java 코드
public enum JobType { POLICE, ROBBER }

public abstract class Job {
  public int speedLevel;

  public abstract JobType getType();
}

public class Police extends Job {
  public int strengthLevel;
  public int fame;

  @Override public JobType getType() {
    return JobType.POLICE;
  }
}

public class Robber extends Job {
  public int robberyLevel;
  public int infamy;

  @Override public JobType getType() {
    return JobType.ROBBER;
  }
}

public class Human {
  public String name;
  public int health;
  public Job job;

  public int getScore(Job job) {
    switch (job.getType()) {
      case POLICE:
        return ((Police) job).fame * 100;
      case ROBBER:
        return ((Robber) job).infamy * 150;
    }
    // 이 경우는 불가능하니까 exception을 던진다.
    throw new RuntimeException("Unreachable code");
  }
}

// Rust 코드
// Tagged Union에 필요한 enum 필드가 숨겨져 있다
pub enum Job {
  Police {
    strength_level: i32,
    speed_level: i32,
    fame: i32,
  },
  Robber {
    robbery_level: i32,
    speed_level: i32,
    infamy: i32,
  },
}

pub fn get_score(job: &Job) -> i32 {
  match job { // 내부적으로는 switch-case와 원리가 같다
    Job::Police { fame, .. }   => fame * 100,
    Job::Robber { infamy, .. } => infamy * 150,
  }
}

// Scala 코드
// JVM의 런타임 타입 정보를 이용한다
sealed trait Job
case class Police(strengthLevel: Int, speedLevel: Int, fame: Int) extends Job
case class Robber(robberyLevel: Int, speedLevel: Int, infamy: Int) extends Job

def getScore(job: Job): Int =
  job match { // 내부적으로는 switch-case와 원리가 같다
    case Police(_, _, fame)   => fame * 100
    case Robber(_, _, infamy) => infamy * 150
  }

// C++ 코드
tuple<int, string, double> tp;

// C# 코드
(int, string, double) tp;

// Rust 코드
let tp: (i32, String, f64)

// Scala 코드
val tp: (Int, String, Double)

// C# 코드
// 상품을 구매하면 상품과 영수증이 같이온다.
public (Product, Receipt) PurchaseProduct(string productId)

// Scala 코드
// 상품을 구매하면 상품과 영수증이 같이온다.
def purchaseProduct(productId: String): (Product, Receipt)

// Scala 코드 (Scala 2)
sealed trait Either[+A, +B] // 정규 라이브러리에 정의된 타입
case class Left[A](value: A) extends Either[A, Nothing]
case class Right[B](value: B) extends Either[Nothing, B]

val couponCode: Either[Int, String]

// Scala 코드 (Scala 3)
val couponCode: Int | String | Array[Int]

// Typescript 코드
let couponCode: number | string | number[]

// Scala 코드
// 오류 없이 성공했다면 (Product, Receipt),
// 실패했다면 PurchaseError를 내려준다
def purchaseProduct(productId: String): Either[PurchaseError, (Product, Receipt)]

// Rust 코드
// 함수가 오류 없이 성공했다면 (Product, Receipt)
// 실패했다면 PurchaseError를 내려준다
pub fn purchase_product(product_id: &str) -> Result<(Product, Receipt), PurchaseError>

// C++ 코드
Product purchaseProduct(string productId);        // 나는 예외를 과연 던질까 말까...

Product purchaseProduct(string productId) {
  if (productId.empty()) {
    throw new invalid_argument("Invalid id"); // 사실 던졌지롱 ㅋㅋㅋ
  }
  /* ... */
}

// Java 코드
public class PurchaseException extends Exception {
  public PurchaseException(String message) {}
}

// throws PurchaseException을 넣지 않으면 컴파일이 되지 않는다
public Product purchaseProduct(String productId) throws PurchaseException {
  if (productId.isEmpty()) {
    throw new PurchaseException("Invalid id");
  }
  /* ... */
}

// Java 코드
public Product purchaseProduct(String productId) throws Exception {
  // 이 많은 함수들중에서 언제 어디서 exception이 던져질까?
  ShopSystem shopSystem = getShopSystem();
  CalendarSystem calendarSystem = getCalendarSystem();
  Date date = calendarSystem.getCurrentDate();
  Wallet wallet = getWallet();
  Product product = shopSystem.getProduct(productId);
  transactionManager.makeTransaction(product, wallet);
  return product;
}

// Rust 코드
// Product 타입이 아닌 Result<Product, MyError> 타입을 출력하기 때문에
// 에러 처리를 강제합니다.
pub fn purchaseProduct(productId: &str) -> Result<Product, MyError> {
  // Rust의 경우 에러가 발생할 수 있는 함수 호출은 에러가 발생할 경우 '?' 기호로 에러를 리턴한다.
  let shopSystem = getShopSystem()?; // 에러 발생가능
  let calendarSystem = getCalendarSystem();
  let date = calendarSystem.getCurrentDate()?; // 에러 발생가능
  let wallet = getWallet()?; // 에러 발생가능
  let product = shopSystem.getProduct(productId);
  transactionManager.makeTransaction(product, wallet)?; // 에러 발생가능
  return product;
}

// Scala 코드
def purchaseProduct(productId: String): Either[PurchaseError, Product]

// Rust 코드
pub fn purchase_product(product_id: &str) -> Result<Product, PurchaseError>

// Go 코드
func purchaseProduct(productId string) (Product, error)