9가지 프로그래밍 언어로 배우는 개념: 3편 - 메타프로그래밍

// C++ 코드
// 상위 타입 parent
class Parent {};

// 하위 타입 Child, Parent를 상속받음
class Child : public Parent {};

// Child 타입을 Parent 타입으로 업캐스팅한다. 그냥 대입하면 끝.
Parent* parent = new Child(); 

// Parent 타입을 Child 타입으로 다운캐스팅한다. dynamic_cast를 사용해야한다.
Child* child = dynamic_cast<Child*>(parent);

// C++ 코드
class Parent {};

// 2개의 하위 타입
class ChildA : public Parent {}
class ChildB : public Parent {}

// ChildA 타입을 업캐스팅한다.
Parent* parent = new ChildA();

// (ChildA가 있는) Parent 타입을 ChildB로 다운캐스팅한다.
// ChildA 타입은 ChildB 타입이 아니므로 null이 내려온다.
ChildB* child = dynamic_cast<ChildB*>(parent);

// C++ 코드
// type_info의 대략적인 정의
class type_info {
public:
  // 복사 생성 불가
  type_info(const type_info& rhs) = delete;

  // 타입의 해쉬
  size_t hash_code() const;

  // 타입간의 비교 연산자
  bool operator==(const type_info& rhs) const;

  // 복사 불가
  type_info& operator=(const type_info& rhs) = delete;

  // 이름을 가져오는 함수, 컴파일러마다 결과가 다름
  const char* name() const;
};

// A 클래스 정의
class A {};

// A 클래스 생성
A a = new A();

// a의 type_info 가져오기
type_info info = typeid(a);

// C++ 코드
// 각 타입들을 생성한 횟수 
unordered_map<type_index, int> call_count;

// 타입의 인스턴스를 생성하는 함수, 타입별로 생성 횟수를 센다.
template<typename T>
T create() {
  creation_count[type_index(typeid(T))]++;
  return T();
}

// Java 코드
// Class는 Invariant하기 때문에 `Class<?>`로 키타입을 설정해야한다.
// 여기서 ?는 타입이 일관적이지 않음을 의미한다.
HashMap<Class<?>, Integer> call_count = new HashMap<>();

// 인수로 받은 object를 타입별로 세는 함수
void increaseCallCount(Object object) {
  Integer integer = call_count.getOrDefault(object.getClass(), 0);
  call_count.put(object.getClass(), integer + 1);
}

// Java 코드
// Class<T>의 대략적인 정의
public final class Class<T> {
  // 타입 이름을 가져오는 메소드
  public String getTypeName() {
    /* ... */
  }

  // 필드 정보들을 가져오는 메소드
  public Field[] getFields() {
    /* ... */
  }

  // 메소드 정보들을 가져오는 메소드
  public Method[] getDeclaredMethods() {
    /* ... */
  }

  /* ... */
}

// Java 코드
// Json으로 직렬화하는 정말 대략적인 함수
public static String jsonify(Object object) {
  Class<?> clazz = object.getClass();
  Field[] fields = clazz.getFields();
  StringBuilder stringBuilder = new StringBuilder();

  stringBuilder.append("{\n");
  for (int i = 0; i < fields.length; i++) {
    Field field = fields[i];
    stringBuilder.append("  \"");
    stringBuilder.append(field.getName());
    stringBuilder.append("\": ");

    // 필드가 Integer 타입일 때
    if (field.getType().equals(Integer.class))  {
      stringBuilder.append(field.get(object));

    // 필드가 String 타입일 때
    } else if (field.getType().equals(String.class)) {
      stringBuilder.append("\"");
      stringBuilder.append(field.get(object));
      stringBuilder.append("\"");
    }
    // 마지막 필드가 아닐 때는 콤마 달기
    if (i != fields.length - 1) {
      stringBuilder.append(',');
    }
    stringBuilder.append('\n');
  }
  stringBuilder.append("}");

  return stringBuilder.toString();
}

// Item 클래스 정의
public class Item {
  public String itemTag;
  public int amount;
}

// Item 생성
Item item = new Item();
item.tag = "Rare";
item.amount = 5;

// Item json화
String result = jsonify(item);
/* result에는 다음 데이터가 담겨진다
{
  "tag": "Rare",
  "amount": 5
}
*/

// Java 코드
// Class<T>의 대략적인 정의
public final class Class<T> {
  /* ... */

  // 어노테이션 정보들을 가져오는 메소드
  public Annotation[] getAnnotations() {
    /* ... */
  }

  /* ... */
}

// Java 코드
enum CasingType { camelCase, snake_case }

@Target(ElementType.Field)
@Rentention(RententionPolicy.RUNTIME)
public @interface Casing {
  CasingType casingType default CasingType.camelCase;
}

//Java 코드
public class Item {
  @Casing(CasingType.snake_case)
  public String itemTag;
  public int amount;
}

// JVM 계열 언어인 Kotlin, Scala는 생략

// C# 코드
// attribute라고 부른다.
enum ECasingType { CamelCase, snake_case }
public class CasingTypeAttribute : System.Attribute {
  public ECasingType casingType;
}

// Typescript 코드
// Decorator라고 부른다. 2022년 7월 기준 experimental
type CasingType = "camelCase" | "snake_case"
function casing(casingType: CasingType) {
  return Reflect.metadata(Symbol("casingType"), casingType);
}

// Go 코드
// Struct tag라고 부른다.
type Item struct {
  itemTag string `casing:"snake_case"`
  amount int
}

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

// A.value는 int 타입
struct A {
  int value;
};

// B.value는 float 타입
struct B {
  float value;
};

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

// C++ 코드
struct C {};

C c;
printValue(c);

// C++ 컴파일러(clang++) 에러 메시지
error: no member named 'value' in 'C'
                cout << t.value << endl;
                        ~ ^

// C++ 코드
class A {};

// B의 상위 타입은 A다
class B : A {};

// result는 true
bool result = std::is_base_of<A, B>::value;

// C++ 코드
// 구현 1
template <typename Base>
bool is_convertible(Base* base) {
  return true;
}

// 구현 2
// 구현 1을 적용할 수 없을 경우 사용된다
template <typename>
bool is_convertible(void* unknown) {
  return false;
}

class A {};

class B : A {};
B* b = new B();
// A는 B의 상위 타입이기에 A*에 B*를 대입할 수 있다
// 구현 1을 적용해도 문제없기에 is_convertible<A>(b)은 구현 1을 사용한다
// 따라서 true가 출력된다
is_convertible<A>(b);

class C {};
C* c = new C();
// A는 C의 상위 타입이 아니기에 A*에 C*를 대입할 수 없어
// 구현 1을 적용하면 컴파일 에러가 나기에 is_convertible<A>(b)은 구현 2을 사용한다
// 따라서 false가 출력된다
is_convertible<A>(c);

// C++ 코드
// 매크로 함수 선언
#define DEF_PRINT_VALUE(T)    \
  void printValue(T t) {      \
    cout << t.value << endl;  \
  }

// A.value는 int 타입
struct A {
  int value;
};

// B.value는 float 타입
struct B {
  float value;
};

// A와 B 버전에 대한 오버로딩 함수 생성
DEF_PRINT_VALUE(A)
DEF_PRINT_VALUE(B)

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

// C++ 코드
struct C {};

DEF_PRINT_VALUE(C)

// C++ 컴파일러(clang++) 에러 메시지
error: no member named 'value' in 'C'
DEF_PRINT_VALUE(C)
^~~~~~~~~~~~~~~~~~
note: expanded from macro 'DEF_PRINT_VALUE'
                        cout << t.value << endl;  \

// C++ 코드
// C/C++ 매크로 정의
#define DEF_PRINT_FIELD(T, fieldName)  \
  void print_##fieldName(T t) {        \
    cout << t.fieldName << endl;       \
  }

struct Human {
  string name;
  int age;
  string role; 
};

DEF_PRINT_FIELD(Human, name)
// 아래 코드가 생성된다.
//  void print_name(T t) {
//    cout << t.name << endl;
//  }

DEF_PRINT_FIELD(Human, age)
// 아래 코드가 생성된다.
//  void print_age(T t) {
//    cout << t.age << endl;
//  }

DEF_PRINT_FIELD(Human, role)
// 아래 코드가 생성된다.
//  void print_role(T t) {
//    cout << t.role << endl;
//  }

Human human = { "mango", 23, "software engineer" };

print_name(human);
print_age(human);
print_role(human);

// Scala 코드
// 메소드 생성하는 매크로 어노테이션 정의
class Printer extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro Printer.impl
}

// 매크로 정의
object Printer {
  def impl(c: whitebox.Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
    import c.universe._

    // 어노테이션을 받은 클래스의 추상 구문 트리를 가져온다
    annottees.map(_.tree) match {
      case (clazz: ClassDef) :: Nil =>
        // 모든 필드들을 조회해 print 메소드들을 생성한다
        val printMethods = clazz.impl.body.collect {
          case valDef: ValDef if valDef.mods.hasFlag(Flag.CASEACCESSOR) =>
            q"""
            def ${TermName(s"print_${valDef.name}")}(): Unit =
              println(${valDef.name})
            """
        }

        // 생성된 print 메소드들을 이어붙힌다
        c.Expr(
          ClassDef(
            clazz.mods,
            clazz.name,
            clazz.tparams,
            Template(
              clazz.impl.parents,
              clazz.impl.self,
              clazz.impl.body ++ printMethods
            )
          )
        )
      case _ =>
        // class가 아닐 경우 에러를 낸다
        c.abort(c.enclosingPosition, "only classes can use @Printer")
    }
  }
}

// 매크로 어노테이션을 적용한 클래스를 정의한다
@Printer
case class Human(
  name: String,
  age: Int,
  role: String
)

// 생성된 메소드들을 마음껏 활용한다
val human = Human("mango", 23, "software engineer");
human.print_name();
human.print_age();
human.print_role();

// Rust 코드
// attribute 매크로 정의
#[proc_macro_attribute]
pub fn make_printers(
  _attr: proc_macro::TokenStream,
  item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
  // 추상 구문 트리를 분석한다
  let derived_item = syn::parse_macro_input!(item as DeriveInput);
  let item_ident = &derived_item.ident;

  // attribute를 받은 struct의 구조를 가져온다
  let printers = match &derived_item.data {
    // 모든 필드들을 조회해 print 메소드들을 생성한다
    syn::Data::Struct(data) => data.fields.iter().map(|field| {
      let field_ident = field.ident.as_ref().unwrap();
      let printer_ident = proc_macro2::Ident::new(
        &format!("print_{}", field_ident),
        proc_macro2::Span::call_site(),
      );
      quote! {
        pub fn #printer_ident(&self){
          println!("{}", self.#field_ident);
        }
      }
    }),

    // sturct가 아닐 경우 에러를 낸다
    _ => compile_error!("only structs can use make_printers"),
  };

  // 생성된 print 메소드들을 추가한다
  quote! {
    #derived_item
    impl #item_ident {
      #(#printers)*
    }
  }.into()
}

// attribute 매크로를 적용한 struct를 정의한다
#[make_printers]
struct Human {
  pub name: String,
  pub age: i32,
  pub role: String,
}

// 생성된 메소드들을 마음껏 활용한다
let human = Human {
  name: "mango".to_owned(),
  age: 23,
  role: "software engineer".to_owned(),
};

human.print_name();
human.print_age();
human.print_role();