PhilipWitte

type
  CanDance = concept x
    dance(x) # `x` is anything that has a `dance` procedure

proc doBallet(dancer: CanDance) =
  # `dancer` can be anything that `CanDance`
  dance(dancer)

# ---

PhilipWitte

type
  CArray{.unchecked.}[T] = ptr array[1, T]

type
  A = object
    items: ptr float
  
  B = object
    items: CArray[float]

PhilipWitte

# Inheritance implies runtime memory overhead, so using it for small things like Particles
# is not ideal even though inheritance (to a Sprite base-type for instance) might be useful.

# We could 'auto compose' types instead as a way to use limited inheritance without it's costs

type
  Sprite = object
    resource: Image
    position: Vector
    rotation: Vector

PhilipWitte

// INSTRUCTIONS:
// Compile with `gcc -s -O3 -flto -o bench bench.c`
// Run with `./bench 100000 10000`

// IMPORTANT:
// The two parameters are REQUIRED and are the numbers for:
//   1. How many points in the array.
//   2. How many times to cycle through the array.
//
// The numbers are not multiplied to ensure the compiler can't cheat.

PhilipWitte

{.this: self.}
import syntax

type
  Person = object
    age: int
    name: string

var
  boys: seq[Person]

PhilipWitte

import brim

# ---

type
  Position = object
    x, y: float

  Velocity = object

PhilipWitte

import macros

# ---------- ---------- ---------- #


proc hasPragma(procedure:expr, name:string): bool {.compileTime.} =
  # checks if a procedure has a specific pragma
  let procPragma = procedure[4]#.pragma
  for p in procPragma.children:
    if p.repr == name:

PhilipWitte

import tables

# ---

type ID = int

var nextTypeID {.compileTime.}: ID

proc typeID(T:typedesc): ID =
  const id = nextTypeID

PhilipWitte

import macros

# --- --- --- #


type
  Base* {.pure inheritable.} = object
  Comp* {.pure inheritable.} = object

PhilipWitte

import StrUtils, Times


type Vector = tuple[x, y, z, w:float]

proc new(T:typedesc[Vector], x, y, z, w:float): Vector {.noSideEffect, noInit, inline.} =
  result.x = x
  result.y = y
  result.z = z