Data Driven Template engine

test-cpp.chrobry

// import './serialization.chrobry'

inject
```
  #pragma once
  #include <string>
  #include <sstream>
```

extern 'int' 'float' {
  impl Display
  ```
    std::string Display(%{ $TYPENAME }% self) { return std::to_string(self); }
  ```

  impl Clone
  ```
    %{ $TYPENAME }% Clone(%{ $TYPENAME }% self) { return self; }
  ```
}

extern 'std::string' {
  impl Display
  ```
    std::string Display(const std::string& self) { return self; }
  ```

  impl Clone
  ```
    std::string Clone(const std::string& self) { return self; }
  ```
}

@Display
@Clone
struct Foo {
  a: 'int',
  b: 'std::string',
  c: Status,
  d: 'float',
}

@Display
@Clone
enum Status {
  Ok,
  Error,
}

impl struct Display
```
  std::string Display(const %{ $TYPENAME }%& self) {
    std::stringstream result("%{ $TYPENAME }% {\n");
    %{
      for $name $type in fields [where $type impl Display]
      ```
        result << "%{ $name }%: " << Display(self.%{ $name }%) << "\n";
      ```
    }%
    result << " }";
    return result;
  }
```

impl enum Display
```
  std::string Display(%{ $TYPENAME }% self) {
    std::stringstream result("%{ $TYPENAME }%::");
    %{
      match $name in fields
      ```
        result << "%{ $name }%";
      ```
    }%
    return result;
  }
```

impl struct Clone [where fields impl Clone Default]
```
  %{ $TYPENAME }% Clone(const %{ $TYPENAME }%& self) {
    %{ $TYPENAME }% result = {
      %{
        for $name $type in fields
        ```
          Clone(self.%{ $name }%),
        ```
      }%
    };
    return result;
  }
```

impl enum Clone
```
  %{ $TYPENAME }% Clone(%{ $TYPENAME }% self) {
    return self;
  }
```