I've been daydreaming about this language where you can define different functions with the same name but whose arguments are of different type (or length).

Here's a naive example, assuming a C-like syntax.

```c
struct vect {
  int x;
  int y;
};

struct guy {
  struct vect pos;
  char *name;
};

struct guy new_guy(vect v, char *name) {
  struct guy g;
  g.pos = v;
  g.name = name;
  return g;
}

struct guy new_guy(int x, int y, char *name) {
  struct vect v;
  v.x = x;
  v.y = y;
  return new_guy(v, name);
}

int get_x(struct vect v) {
  return v.x;
}

int get_x(struct guy g) {
  return g.pos.x;
}

```

The point would be in avoiding having long names like: `get_vect_x` and `get_guy_x`, etc. The compiler knows what types we are using to call a function so it shouldn't be a problem to figure out which definition to use.

There could also be different definitions for different number of arguments.