a : ptr = cast (ptr) myobj;
x : int = float (num);

$ifdef x86_64
     def memcpy (dst, src : ptr; size : int64; alignVal : int = 4; isVolatile : bool = false)       external "llvm.memcpy.p0i8.p0i8.i64";
     def memset (dst : ptr; val : byte; len : int64; alignVal : int = 4; isVolatile : bool = false) external "llvm.memset.p0i8.i64";
$else
     def memcpy (dst, src : ptr; size : int; alignVal : int = 4; isVolatile : bool = false)         external "llvm.memcpy.p0i8.p0i8.i32";
     def memset (dst : ptr; val : byte; len : int; alignVal : int = 4; isVolatile : bool = false)   external "llvm.memset.p0i8.i32";
$endif

alias LPCSTR = ^char;
alias GLSecondaryColor3bEXT = def gl_cc (red: GLbyte; green: GLbyte; blue: GLbyte);

<4 x Int> A = <2, 5> ++ <3, 5> // Склейка списков
[7 x Int] x = [1,2,3...]
[3 x Int] r = [1] ++ [2,4]

Float a = a ** 2

Int a = static_cast<float> 1.f
auto pl = dynamic_cast<Player> obj

String hello = "Hello " ++ "World!"

Vector<int> a = {1, 2, 4}
a.push(12)

onClick (lambda[a](Int x, Int y) -> Int

   auto r = a.pop()
   putStr x+y+r
   return x+y+r

end)

for (auto i : a)
...
end

for (Int a in [0..10])
...
end

import system
import glfw
import openal
import opengl

enum Align = Left, Right, Center // Перечисление
typeclass Num = Int, Float, Double // Класс типа, для автоматической генерации, на подобие шаблонов
alias String = [Char]

// Итераторы, конечто же по другому все будет, это там пример
class MyList <Int size>
private:
   [Size x Int] data
   Int cursor = 0

public:

   def begin() -> ptr<Int> :: inline
    addr (data[0])

   def end() -> ptr<Int> :: inline
    addr (data[size-1])

   def next() -> ptr<Int> :: inline
    addr (data[++cursor])

   def prev() -> ptr<Int> :: inline
    addr (data[--cursor])

   def get() -> Int :: inline
    data[cursor]

end

alias Vec4f = <4 x Float> :: x <-> r, y <-> g, z <-> b, w <-> a
Vec4f color = <0,0,0,0>
color.a = 1; // или color.w = 1 будет эквивалентно

alias Mat4f = [4 x Vec4f] :: a, b, c, d

const Mat4f.zero = [<0.f, ...>, ...]
const Mat4f.indent = // Возможно сделаю вместо точки ::, т.е. Mat4f::Indent = [...]
[
   <1.f, 0.f, 0.f ,0.f>,
   <0.f, 1.f, 0.f ,0.f>,
   <0.f, 0.f, 1.f ,0.f>,
   <0.f, 0.f, 0.f ,1.f>
]

def sum (const Num a, b) -> auto
   a+b

// Возведение в степень
def binary ** (<Num> a, <Num> a, b) -> auto :: inline
   fpow (a, b)
end

// Перемножение 2х чисел
def binary * (const Mat4f m1, m2) -> Mat4f :: inline
     
   Mat4f res
     
   for (Int i in [0..3]) :: unroll (all)
      
    Vec4f ci = m1[i][0]*m2[0];
      
    for (Int i in [0..3]) :: unroll (all)
     ci += m[i][j]*m2[j]
      
    res[i] = ci
      
   end
     
   return res

end

def updateMatrices()

   Mat4f mr = math::rotateMat    (Mat4f.indent, rotation, <0.f, 0.f, 1.f>)
   Mat4f mt = math::translateMat (Mat4f.indent, <position, 0.f>)
   Mat4f ms = math::scaleMat     (Mat4f.indent, <scale   , 1.f>)

   modelMatrix = mt*mr*ms;
   MVPMatrix   = camera.MVPMatrix*modelMatrix

end

[unique_ptr<Object>] objects
objects ++= object
objects.erase object.get()

[String <- unique_ptr<Object>] objects :: Hash

vec2 move2Target (vec2 current, vec2 target, float speed) {

    vec2 dir (target.x - current.x, target.y - target.x);
    float length = sqrt (dir.x*dir.x + dir.y*dir.y);
    dir = vec2 (dir.x/length, dir.y/length); // Получили направление в диапазоне [0..1]
    return vec2 (current.x+dir.x+speed, current.y+dir.y*speed);

}

player.x < platform.x+platform.halfw &&
player.x > platform.x-platform.halfw &&
player.y-player.radius < platform.y+platform.halfh &&
player.y+player.radius > platform.y-platform.halfh &&
player.velocity < 0

public static function interpTo (current : Float, target : Float, deltaTime : Float, interpSpeed : Float) {

    if (interpSpeed == 0)
     return target;

    var dist : Float = target - current;

    if (dist*dist < SMALL_NUMBER)
     return target;

    var deltaMove : Float = dist*deltaTime*interpSpeed;
    return current+deltaMove;
       
}

x = interpTo (x, x2, dtime, 10);
y = interpTo (y, y2, dtime, 10);

public static function interpTo (current : Float, target : Float, deltaTime : Float, interpSpeed : Float) {

   if (interpSpeed == 0)
    return target;

   var dist : Float = target - current;

   if (dist*dist < SMALL_NUMBER)
    return target;

   var deltaMove : Float = dist*deltaTime*interpSpeed;
   return current+deltaMove;
     
}

...

x = interpTo (x, x2, dtime, 10);
y = interpTo (y, y2, dtime, 10);