bound methods

[thejoshwolfe]

struct Rand {
  fn by_val_this(rand: Rand) -> bool {...}
  fn next_unsafe(rand: &Rand) -> u32 {...}
  fn next_safe  (rand: &Rand) -> u32 {...}
  fn const_pointer_this(rand: &const Rand) -> u32 {...}
  fn fill_array(rand: &Rand, array: []u32) {...}
  // generic methods:
  fn range_inclusive(t: type)(rand: &Rand, min  : t, max: t) -> t {...}
  fn range_exclusive(t: type)(rand: &Rand, start: t, end: t) -> t {...}
}

fn main() {
  var rand = Rand{};
  // this stuff already works:
  rand.by_val_this();        // equivalent to `Rand.by_val_this(rand)`
  rand.next_unsafe();        // equivalent to `Rand.next_unsafe(&rand)`
  rand.const_pointer_this(); // equivalent to `Rand.const_pointer_this(&rand)`

  var preferences = read_preferences_at_runtime();

  const bound_fill_array: fn.(&Rand, []u32) = rand.fill_array;
  // implicit type is:
  // struct fn.(&Rand, []u32) {
  //   func: fn(&Rand, []u32),
  //   this: &Rand,
  // }
  // value is `{Rand.fill_array, rand}`
  var buffer = []u32{0, 0, 0, 0};
  bound_fill_array(buffer); // equivalent to `bound_fill_array.func(bound_fill_array.this, buffer)`

  const bound_next_func: fn.(&Rand)->u32 = if (preferences.safety) rand.next_safe else rand.next_unsafe;
  // implicit type is:
  // struct fn.(&Rand)->u32 {
  //   func: fn(&Rand)->u32,
  //   this: &Rand,
  // }
  bound_next_func(); // equivalent to `bound_next_func.func(bound_next_func.this)`

  // error: generic functions have to be instantiated at compile time
  //const range_func: fn.(t: type)(&Rand, t, t) = if (preferences.inclusivity) rand.range_inclusive else rand.range_exclusive;

  const range_func: fn.(&Rand, i16, i16)->i16 = if (preferences.inclusivity) rand.range_inclusive(i16) else rand.range_exclusive(i16);
  // implicit type is:
  // struct fn.(&Rand, i16, i16)->i16 {
  //   func: fn(&Rand, i16, i16)->i16,
  //   this: &Rand,
  // }
  range_func(-1000, 1000); // equivalent `range_func.func(range_func.this, -1000, 1000)`

  // the usual function pointer coercion rules apply for the `this` parameter:
  const maybe_const_this: fn.(&const Rand)->u32 = if (preferences.do_things) rand.next_unsafe else rand.const_pointer_this;

  // error: method signatures have to match:
  //const broken = if (preferences.do_things) rand.next_unsafe else rand.fill_array;

  // error: pointer and by-val this do not coerce
  //const what_is_this = if (preferences.do_things) rand.next_unsafe else rand.by_val_this;
}

[andrewrk]

Is this still necessary given the new generic syntax?

const bound_next_func: fn.(&Rand)->u32 = if (preferences.safety) rand.next_safe else rand.next_unsafe;
bound_next_func(); // equivalent to `bound_next_func.func(bound_next_func.this)`

How about instead:

const nextFunc = if (preferences.safety) Rand.nextSafe else Rand.nextUnsafe;
nextFunc(rand);

[andrewrk]

The new plan is to get rid of the BoundFn type. I think this is possible now that we have @as instead of function calls. cc @SpexGuy