9가지 프로그래밍 언어로 배우는 개념: 2편 - 다형성

// C 코드
int addInt(int a, int b) {
  return a + b;
}

float addFloat(float a, float b) {
  return a + b;
}

// C++ 코드
// A함수: int끼리 add 하는 함수
int add(int a, int b) {
  return a + b;
}

// B함수: float끼리 add 하는 함수
float add(float a, float b) {
  return a + b;
}

int a = add(1, 1);       // 여기서는 int끼리 add 하는 A함수를 쓴다.
float b = add(1.0f, 1.0f); // 여기서는 float끼리 add 하는 B함수를 쓴다.

// C/C++ 코드
int getGrade(int score) {
  return a * 2 / 100;
}

int getGrade(string gradeString) {
  return toInt(trim(a));   // 앞뒤 공백 삭제 후 int로 파싱
}

int b = getGrade(getScore()); // 과연 어느 함수가 호출될까?

// C++ 코드
// score의 기본값은 100으로 설정한다
int getGrade(int score = 100) {
  return a * 2 / 100;
}

int score = getScore();
int grade = getGrade(); // 실수로 score 변수를 사용하지 않았다!

// Java 코드
public interface Food {
  int getCalories();
  int getWeight();

  default float getCaloriesPerWeight() {
   return getCalories() / getWeight();
  }
}

// Java 코드
public interface Food {
  int getCalories();
}

public class Pizza implements Food {
  int sliceCount; // 피자 조각 개수

  @Override public int getCalories() {
    return sliceCount * 300;
  }
}

public class Burger implements Food {
  public enum BurgerType { CHEESE, BACON_CHEESE }

  BurgerType burgerType;  // 버거의 종류

  @Override public int getCalories() {
    switch (burgerType) {
      case CHEESE:
        return 700;
      case BACON_CHEESE:
        return 900;
    }
  }
}

Food pizza = cookPizza();
Food burger = cookBurger();

// 하나의 Food 타입으로 두 가지 다른 동작을 한다.
int pizzaCalories = pizza.getCalories();
int burgerCalories = burger.getCalories();

// Scala 코드
sealed trait BurgerType
case object Cheese extends BurgerType
case object BaconCheese extends BurgerType

sealed trait Food
case class Pizza(pieceCount: Int) extends Food
case class Burger(burgerType: BurgerType) extends Food

def getCalories(food: Food): Int = food match {
  case Pizza(pieceCount)  =>
    pieceCount * 300
  case Burger(burgerType) =>
    burgerType match {
      case Cheese      => 700
      case BaconCheese => 800
    }
}

val food: Food = getPizza()
val calories: Int = getCalories(food)

// Rust 코드
pub enum BurgerType {
  Cheese,
  BaconCheese,
}

pub enum Food {
  Pizza { piece_count: i32 },
  Burger{ burger_type: BurgerType },
}

pub fn get_calories(food: &Food) -> i32 {
  match food {
    Food::Pizza { piece_count }  => piece_count * 300,
    Food::Burger { burger_type } =>
      match burger_type {
        BurgerType::Cheese      => 700,
        BurgerType::BaconCheese => 800,
      },
  }
}

let food: Food = get_pizza();
let calories: i32 = get_calories(&food);

// Java 코드
public class ArrayList<T> {
  private T[] elementData;
  private int size;

  public boolean add(T e) {
    /* ... */
    elementData[size++] = e;
    return true;
  }
}

ArrayList<Integer> intList = new ArrayList<Integer>();
ArrayList<String> stringList = new ArrayList<String>();

// ArrayList<Integer>의 add는 Integer를 받는다
intList.add(5);
intList.add(10);
intList.add(15);

// ArrayList<String>의 add는 String를 받는다
stringList.add("one");
stringList.add("two");
stringList.add("three");

// Java 코드
// value를 size 만큼 채워서 ArrayList를 출력하는 함수
public <T> ArrayList<T> fill(T value, int size) {
  ArrayList<T> ret = new ArrayList<T>();
  for (int i = 0; i < size; i++) {
    ret.add(value);
  }
  return ret;
}

// a와 b를 비교해서 더 높은 것을 출력하는 함수
// T는 Comparable<T> 인터페이스를 구현하고 있어야 한다
public <T extends Comparable<T>> T max(T a, T b) {
  if (a.compareTo(b) >= 0) {
    return a;
  } else {
    return b;
  }
}

// C++ 코드
template<typename T>
T add(T a, T b) {
  return a + b;
}

int a = add<int>(10, 5);          // 여기서는 T가 int이다.
float b = add<float>(7.5f, 2.0f); // 여기서는 T가 float이다.

// T 위치에 지정된 타입을 치환하여 따로 구현한 것과 동일하다.
// int add(int a, int b) {
//   return a + b;
// }
//
// float add(float a, float b) {
//   return a + b;
// }

// C++ 코드
template<typename T>
void printValue(T a) {
  cout << a.value << endl;
}

struct A {
 int value;
};

struct B {
 float value;
};

A a = { 5 };
B b = { 10.5f };
printValue(a);
printValue(b);

// C# 코드
// 인터페이스에서만 활용 가능하다
IEnumerable<string> stringList = new List<string>();
IEnumerable<object> objectList = stringList;

// Kotlin 코드
// 인터페이스에서 활용 가능하다
val intList: List<Integer> = listof()
val objectList: List<Object> = intList

// Scala 코드
// 자유롭게 가능하다
val intList: List[Int] = List()
val anyList: List[Any] = intList

// Typescript 코드
let intArray: Array<number> = []
let anyArray: Array<any> = intArray

// Rust 코드
let i32Box: Box<i32> = Box::new(4);
let anyBox: Box<dyn Any> = i32Box;

// C# 코드
// C#의 IComparer<T>의 대략적인 구현
public interface IComparer<in T> {
  int Compare(T x, T y);
}

IComparer<object> objectComparer;

// stringComparer에 objectComparer를 대입할 수 있다.
IComparer<string> stringComparer = objectComparer;

// C# 코드
string str = "Hi";
object obj = str;

// C# 코드
// int를 string으로 변환시키는 익명 함수
Func<int, string> toString = x => x.ToString();

// 출력 타입을 object로 취급해도 괜찮다
Func<int, object> func = toString;

// 어차피 둘 다 출력을 object 타입에 대입시킬 수 있다
object toStringOut = square(5);
object funcOut = func(5);

// C# 코드
public interface IGenerator<out T> {
  T Generate();
}

// string를 생성하는 인터페이스
public class StringGenerator : IGenerator<string> {
  public string Generate() {
    return "Hi";
  }
}

// int generate() 메소드는 Object generate()로 변환이 가능하다
IGenerator<string> stringGenerator = new StringGenerator();
IGenerator<object> objectGenerator = stringGenerator;

// C# 코드
// object를 string으로 변환시키는 익명 함수
Func<object, string> toString = x => x.ToString();

// 입력 타입을 string으로 취급해도 괜찮다
Func<string, string> func = toString;

// 어차피 둘 다 입력으로 string를 받을 수 있다
string toStringOut = toString("hello");
string funcOut = func("hi");

// 인터페이스에서는...
public interface IConsumer<in T> {
  void consume(T v);
}

// object를 입력받는 인터페이스
public class ObjectConsumer : IConsumer<object> {
  public void consume(object v) {
    Console.WriteLine(v.ToString());
  }
}

// void consume(object value) 메소드는
// void consume(string value)로 변환이 가능하다.
IConsumer<object> objectConsumer = new ObjectConsumer();
IConsumer<string> stringConsumer = objectConsumer;

// Scala 코드
sealed trait Fruit
case class Apple(weight: Int) extends Fruit
case class Banana(length: Int) extends Fruit

val appleList: List[Apple] = List()
val fruitList: List[Fruit] = appleList

// Java 코드
public interface Addable {
  Addable add(Addable value); // CustomInt를 사용할 수 없다
}

public class CustomInt implements Addable {
  public int value;

  public CustomInt(int value) {
    value = value;
  }

  @Override public Addable add(Addable rhs) {
    return new CustomInt(value + ((CustomInt) rhs).value); // 캐스팅 해야 함
  }
}

Addable a = new CustomInt(10);
Addable b = a.add(new CustomInt(5)); // Addable 타입이 출력된다

// Java 코드
public interface Addable<T> {
  T add(T value);
}

public class CustomInt implements Addable<CustomInt> {
  public int value;

  public CustomInt(int value) {
    value = value;
  }

  @Override public CustomInt add(CustomInt rhs) {
    return new CustomInt(value + rhs.value);
  }
}

Addable<CustomInt> a = new CustomInt(10);
CustomInt b = a.add(new CustomInt(5)); // CustomInt 타입이 출력된다

// Java 코드
public class CustomComplex extends CustomInt {
  public int imaginaryValue;

  public CustomComplex(int value, int imaginaryValue) {
    super(value); // 부모의 생성자 활용
    imaginaryValue = imaginaryValue;
  }

  // 나머지 함수는 그대로 상속받는다
}

CustomComplex a = new CustomComplex(1, 2);
CustomInt b = a.add(new CustomComplex(3, 4)); // CustomInt가 출력된다!!!

// Java 코드, 주의: 컴파일할 수 없는 코드
public interface Entity {
  Entity parseFromString(String string);
}

public class Human implements Entity {
  private String name;

  @Override public Entity parseFromString(String string) {
    Human human = new Human();
    human.name = string;
    return human;
  }
}

public class Sword implements Entity {
  private int attackPoint;

  @Override public Entity parseFromString(String string) {
    Sword sword = new Sword();
    sword.attackPoint = Integer.parseInt(string);
    return sword;
  }
}

// T는 Entity를 상속받음
public <T extends Entity> Entity parseEntityFromString(String string) {
  return T.parseFromString(string);
}

Entity human = parseEntityFromString<Human>("mango");
Entity sword = parseEntityFromString<Sword>("120");

// Scala 코드
// "숫자"를 위한 타입클래스
// 인터페이스와 제네릭을 섞어서 타입클래스를 만든다
trait Numeric[T] {
  def plus(lhs: T, rhs: T): T
  /* ... */
}

// Numeric를 상속받지 않는다
case class CustomInt(value: Int)

// Numeric[CustomInt]의 정의
implicit val numeric: Numeric[CustomInt] =
  new Numeric[CustomInt] {
    def plus(lhs: CustomInt, rhs: CustomInt): CustomInt =
      CustomInt(lhs.value + rhs.value)
    /* ... */
  }

// T는 Numeric 타입클래스를 가지고 있어야 한다
def addThree[T: Numeric](first: T, second: T, third: T) =
  first + second + third

// addThree 함수를 자유롭게 사용할 수 있다
val intAdds: Int =
  addThree(5, 10, 20)

val customIntAdds: CustomInt =
  addThree(CustomInt(5), CustomInt(10), CustomInt(20))

val floatAdds: Float =
  addThree(0.5, 1.2, 500.0)

// Rust 코드
// 덧셈을 위한 trait, Self는 자기 자신 타입이다
pub trait Add<Rhs = Self> {
  type Output;
  fn add(self, rhs: Rhs) -> Self::Output;
}

// Rust에는 상속이 없다
#[derive(Clone)]
struct CustomInt(i32);

// Add trait 정의
impl Add for CustomInt {
  type Output = CustomInt;
  fn add(self, other: Self) -> Self {
    CustomInt(self.0 + other.0)
  }
}

// T는 Add<Output = T>를 구현하고 있어야한다
pub fn add_three<T: Add<Output = T>>(first: T, second: T, third: T) -> T {
  first + second + third
}

// Add 함수를 자유롭게 사용할 수 있다.
let int_adds: i32 =
  add_three(5, 10, 20);

let custom_int_adds: CustomInt =
  add_three(CustomInt(5), CustomInt(10), CustomInt(20));

let float_adds: f32 =
  add_three(0.5, 1.2, 500.0);