Are there any high-level untyped languages?

See title.

>>11
I recently followed someone's advice on here, and I used void pointers for all my data types in C in a small project. Trust me, it didn't help reduce the complexity, and it made it around 80% more likely to segfault on the first run after typing some new code. It did save on typing, and because retrieval from structures was implemented with getter functions, it ended up looking a lot like scheme.

>>15

No problem! Here have some code. I know I will never be able to use it for anything anyway:

tree.c

#include <malloc.h>
#include <assert.h>
#include <stdio.h>

#include "trace.h"
#include "utils.h"
#include "tree.h"

p tree_vtable[] = {
  (p)destroy_tree,
  (p)print_tree
};

v init_tree(p self, p item, p left, p right) {C
  P("init_tree: %p to ", self); PS(item); P(", "); PS(left); P(", "); PS(right); P("\n");
  init_object(self, tree_vtable);
  init_fields_tree(self, item, left, right);
R}

v init_fields_tree(p self, p item, p left, p right) {C
  P("init_fields_tree: %p to ", self); PS(item); P(", "); PS(left); P(", "); PS(right); P("\n");
  init(&((struct tree*)self)->item, item);
  init(&((struct tree*)self)->left, left);
  init(&((struct tree*)self)->right, right);
R}



p tree(p item, p left, p right) {C
  P("tree: "); PS(item); P(", "); PS(left); P(", "); PS(right); P("\n");
  p allocation = malloc(sizeof(struct tree));
  assert(allocation);
  init_tree(allocation, item, left, right);
R return allocation;
}

v set_left_tree(p self, p left) {C
  P("set_left_tree: %p to \n", self); PS(left); P("\n");
  set(&((struct tree*)self)->left, left);
R}

v set_right_tree(p self, p right) {C
  P("set_right_tree: %p to \n", self); PS(right); P("\n");
  set(&((struct tree*)self)->right, right);
R}

v set_item_tree(p self, p item) {C
  P("set_item_tree: %p to \n", self); PS(item); P("\n");
  set(&((struct tree*)self)->item, item);
R}

p left_tree(p self) {C
  P("left_tree: %p", self); P("\n");
R return ((struct tree*)self)->left;
}

p right_tree(p self) {C
  P("right_tree: %p", self); P("\n");
R return ((struct tree*)self)->right;
}

p item_tree(p self) {C
  P("item_tree: %p", self); P("\n");
R return ((struct tree*)self)->item;
}

v destroy_tree(p self) {C
  P("destroy_tree: %p", self); P("\n");
  unreg(item_tree(self));
  unreg(left_tree(self));
  unreg(right_tree(self));
R}

v print_tree(FILE* output, p self) {
  fprintf(output, "<tree>");
  fprintf(output, "<item>");
  print_object(output, item_tree(self));
  fprintf(output, "</item>");
  fprintf(output, "<left>");
  print_object(output, left_tree(self));
  fprintf(output, "</left>");
  fprintf(output, "<right>");
  print_object(output, right_tree(self));
  fprintf(output, "</right>");
  fprintf(output, "</tree>");
}

p merge_trees(p tree_left, p tree_right, int take_tree_right, p(*tree_constructor)(p,p,p)) {C
  P("merge_trees: "); PS(tree_left); P(", "); PS(tree_right); P(" %d\n", take_tree_right);
  if(!tree_left) {
    R return tree_right;
  } else if(!tree_right) {
    R return tree_left;
  } else if(!right_tree(tree_left)) {
    R return tree_constructor(item_tree(tree_left), left_tree(tree_left), tree_right);
  } else if(!left_tree(tree_right)) {
    R return tree_constructor(item_tree(tree_right), tree_left, right_tree(tree_right));
  } else if(take_tree_right) {
    R return tree_constructor(item_tree(tree_right), merge_trees(tree_left, left_tree(tree_right), 0, tree_constructor), right_tree(tree_right));
  } else {
    R return tree_constructor(item_tree(tree_left), left_tree(tree_left), merge_trees(right_tree(tree_left), tree_right, 1, tree_constructor));
  }
}

// The root will go down to the left. It's right child becomes the parent.
// The right child must not be null.
p rotate_left_tree(p root, p(*tree_constructor)(p,p,p)) {
  p right_root = right_tree(root);
  assert(right_root);
  return tree_constructor(item_tree(right_root),
                          tree_constructor(item_tree(root),
                                           left_tree(root),
                                           left_tree(right_root)),
                          right_tree(right_root))
}

// The root will move down to the right, with its former left child becoming the root's parent.
// The left child must not be null.
p rotate_right_tree(p root, p(*tree_constructor)(p,p,p)) {
  p left_root = left_tree(root);
  assert(left_root);
  return tree_constructor(item_tree(left_root),
                          left_tree(left_root),
                          tree_constructor(item_tree(root),
                                           right_tree(left_root),
                                           right_tree(root)));
}

int height_tree(p root) {
  if(!root) return 0;
  return max(height_tree(left_tree(root)), height_tree(right_tree(root))) + 1;
}

int size_tree(p root) {
  if(!root) return 0;
  return 1 + size_tree(left_tree(root)) + size_tree(right_tree(root));
}

Some things like inheritance became very elegant, but still, static typing can save you from a lot of segfaults in a language like C.