Polymorphic procedures

Type variables
Authoritative parameters
using with type variables
Baking polymorphs
Modifying polymorph types
Modifying polymorphic functions
Baking values
Auto-baking
Implementing map

Type variables

The dollar sign ($) in Jai indicates a type variable. ¹

Type variables allow for defining a generic form of source code that can work for multiple types. Similar to template metaprogramming in C++, but simpler and cleaner and without any header files.

// from https://youtu.be/BwqeFrlSpuI?t=218
print_number :: (number: $T) {
  // pass number as both int and float,
  // one of them will work out..
  printf("print_number: %d %f\n", number, number);
}

n1: int     = 1;
n2: u8      = 2;
n3: s64     = 3;
n4: float32 = 4;
n5: float64 = 5;

print_number(n1); // 1 0.000000
print_number(n2); // 2 0.000000
print_number(n3); // 3 0.000000
print_number(n4); // 0 4.000000
print_number(n5); // 0 5.000000

Authoritative parameters

For procedures with multiple parameters of the same type variable, use only one dollar sign to identify which parameter is authoritative over the error message. ²

add :: (p: $T, q: T) -> T {
  x := p + q; // does not handle overflow
  return x;
}

n1: u8      = 254;
n2: float32 = 7.63;
n3: u8      = 1;

add(n1, n2); // type mismatch error will state second parameter must match first
add(n1, n3); // ok, types match

toggle example

// from: https://youtu.be/BwqeFrlSpuI?t=501

swap :: (a: ^$T, b: ^T) {
  tmp := *a;
  *a = *b;
  *b = tmp;
}

swap.jai

toggle example

// from: https://youtu.be/BwqeFrlSpuI?t=868

find :: (array: [] $T, item: T) -> s64 {
  for array if it == item return it_index;
  return -1; // (not found)
}

find.jai

toggle example

// from: https://youtu.be/BwqeFrlSpuI?t=1200

do_three_times :: (func: ($T) -> void, arg: T) {
  for 1..3 func(arg);
}

do_three_times.jai

`using` with type variables

Variable types will work with using: ³

Vector2 :: struct {
  x: float = 2.0;
  y: float = 2.1;
}
Vector3 :: struct {
  z: float = 3.2;
  y: float = 3.1;
  x: float = 3.0;
}

using_test :: (using a: $T) {
  printf("a.x is %f\n", x);
  printf("a.y is %f\n", y);
}

v2: Vector2;
v3: Vector3;

// works with values or pointers
using_test(v2);  // a.x is 2.0; a.y is 2.1
using_test(^v2);

using_test(v3);  // a.x is 3.0; a.y is 3.1
using_test(^v3);

Baking polymorphs

See #bake to precompile a polymorphic procedure for a specific type.

baked3 := #bake using_test(T = Vector3);

Modifying polymorph types

See #modify to inject one or more procedures for inspecting and reacting to type variables being passed to a polymorphic procedure.

toggle example

// from: https://youtu.be/7Fsy2WaxLOY?t=1276

get_field :: (info: ^Type_Info_Struct, name: string) -> ^Type_Info_Struct_Member {
  for ^ info.members if it.name == name return it;
  return null;
}

satisfies_struct_interface :: (info: ^Type_Info_Struct, target: ^Type_Info_Struct) -> bool {
  for target.members {
    field := get_field(info, cast(it.name, string)); // dumb cast
    if !field return false;

    if field.type != it.type return false;
  }

  return true;
}

satisfies_interface :: (info: ^Type_Info, target: ^Type_Info) -> bool {
  if info.type != Type_Info_Tag.STRUCT return false;
  if target.type != Type_Info_Tag.STRUCT return false;

  return satisfies_struct_interface(cast(info, ^Type_Info_Struct), cast(target, ^Type_Info_Struct));
}


Ints :: struct { x, y: int; }
Vector2 :: struct { x, y: float; }
Vector4 :: struct { x, y, z, w: float; }

printf("Does Ints satisfy Vector2? : %d\n", satisfies_interface(type_info(Ints), type_info(Vector2))); // 0 (false)
printf("Does Vector4 satisfy Vector2? : %d\n", satisfies_interface(type_info(Vector4), type_info(Vector2))); // 1 (true)
printf("Does Vector2 satisfy Vector4? : %d\n", satisfies_interface(type_info(Vector2), type_info(Vector4))); // 0 (false)

satisfies_interface.jai

Modifying polymorphic functions

See #body_text to generate a string for use as source code of the polymorphic procedure.

toggle example

// from: https://youtu.be/7Fsy2WaxLOY?t=2456

concat :: (s: string, t: string) -> string {
  return case(mprintf("%s%s", s, t), string);
}

length :: (using v: $T) -> float

#body_text (T: ^Type_Info) -> string {

  if T.type != Type_Info_Tag.STRUCT {
    printf("Error: 'length' wants a Vector type, but you gave it something that wasn't a struct!\n");
    return null;
  }

  // this leaks; in real code, you would use a string builder here.

  squares := "x*x";
  if has_field(T, "y") squares = concat(squares, " + y*y");
  if has_field(T, "z") squares = concat(squares, " + z*z");
  if has_field(T, "w") squares = concat(squares, " + w*w");

  s := mprintf("return sqrtf(%s);", squares);

  printf("** Returning generated body text: %s\n", s);

  return cast(s, string); // dumb cast!
}

Vector2 :: struct {
  x : float = 1;
  y : float = 4;
}

Vector3 :: struct {
  x : float = 1;
  y : float = 4;
  z : float = 9;
}

Vector4 :: struct {
  x : float = 1;
  y : float = 4;
  z : float = 9;
  w : float = 16;
}

v2: Vector2;
v3: Vector3;
v4: Vector4;

printf("Length of v2 is: %f\n", length(v2));
printf("Length of v3 is: %f\n", length(v3));
printf("Length of v4 is: %f\n", length(v4));

length_body_text.jai

Baking values

Use #bake_values to precompile a regular procedure with specific parameter values:

multiplier :: (a: float, b: float) -> float {
  return a * b;
}

printf("multiplier(%f, %f) = %f\n", 3, 5, multiplier(3, 5));
// multiplier(3, 5) = 15

uniplier :: #bake_values multiplier(b = -9);

printf("uniplier(%f) = %f\n", 3, uniplier(3));
printf("uniplier(%f) = %f\n", 5, uniplier(5));
// uniplier(3) = -27
// uniplier(5) = -45

Auto-baking

Use the auto-baking operator ($$) to ask the compiler to bake functions when specific parameters have values known at compile-time.

toggle example

// from: https://youtu.be/7Fsy2WaxLOY?t=3110

Spacing_Mode :: enum {
  NONE,
  INDENT,
  EXDENT
}

using Spacing_Mode.members;

print_names_and_values :: (names: [] string, values: [] int, $$ mode: Spacing_Mode.strict, use_dots: bool) {
  if mode == EXDENT printf("       ");
  printf("print_names_and_values says:\n");

  for 0..names.count-1 {
    if mode == INDENT printf("    ");

    printf("%8s:", names[it]);

    if use_dots printf("......");
    else printf("      ")

    printf("%d\n", values[it]);
  }
}

N :: 5;

names  : [N] string;
values : [N] int;

names[0] = "Cow";
names[1] = "Horse";
names[2] = "Pig";
names[3] = "Mule";
names[4] = "Llama";

values[0] = 1;
values[1] = 4;
values[2] = 6;
values[3] = 4;
values[4] = 1;

print_names_and_values(names, values, NONE, false);
print_names_and_values(names, values, INDENT, true);

print_names_and_values_autobake.jai

Implementing map

With polymorphic procedures, higher-order functions like map ⁴ can be implemented, while retaining the speed and type safety of a compiled language.

toggle example

// from: https://youtu.be/7Fsy2WaxLOY?t=3540

map_test :: () {

  /*

  An experiment in programming in a more Lisp-y style.

  */

  N :: 5;

  a: [N] int;
  for 0..N-1 a[it] = it+1;

  for a printf("a[%d] = %d\n", it_index, it);

  // map: apply f to each element of array, returning the resulting array.

  map :: (array: [] $T, f: (T) -> $R) -> [] R {

    result: [] R;
    result.data = malloc(array.count * size_of(R));
    result.count = array.count;

    for array result[it_index] = f(it);

    return result;

  }

  square :: (n: int) -> int { return n*n; }

  b := map(a, square);
  for b printf("b[%d] = %d\n", it_index, it);

  free(b.data);

}

map_test.jai

what the dollar sign indicates is that this is a type variable which means we don’t know what type it is at declaration time. the type of this variable will be determined when the function is called.
“Polymorphic Procedures, part 1” YouTube, uploaded by Jonathan Blow, Apr 1, 2015, https://youtu.be/BwqeFrlSpuI?t=228 ⮌
the reason that we only use the dollar sign once is that the dollar sign tells us which argument is authoritative over what the type should be..
“Polymorphic Procedures, part 1” YouTube, uploaded by Jonathan Blow, Apr 1, 2015, https://youtu.be/BwqeFrlSpuI?t=360 ⮌
here we’ve got a function called using_test, and we’re using the first parameter. Remember that using let’s us refer to these components; it’s like a this pointer.
“Polymorphic Procedures, part 1” YouTube, uploaded by Jonathan Blow, Apr 1, 2015, https://youtu.be/BwqeFrlSpuI?t=1624 ⮌
In many programming languages, map is the name of a higher-order function that applies a given function to each element of a functor, e.g. a list, returning a list of results in the same order.
Wikipedia contributors. “Map (higher-order function).” Wikipedia, The Free Encyclopedia, 11 Mar. 2019. Web. 31 Jul. 2019., https://en.wikipedia.org/w/index.php?title=Map_(higher-order_function)&oldid=887181717 ⮌

jailang 2019 pixeldroid
https://github.com/pixeldroid/jailang

programming pages theme v0.5.21 (https://github.com/pixeldroid/programming-pages)

s	focus search bar ( enter to select, ▲ / ▼ to change selection)
g e	go to examples
g m	go to modules
g o	go to overview
g r	go to reference
h	toggle this help ( esc also exits)

Polymorphic procedures

Type variables

Authoritative parameters

using with type variables

Baking polymorphs

Modifying polymorph types

Modifying polymorphic functions

Baking values

Auto-baking

Implementing map

Keyboard Shortcuts

`using` with type variables