feat(modules): Moved implementation to `rope/`.

Moved the `rope` implementation to the `rope/` module.

rope/leaf.ha

···
+type Leaf = struct {
+	string: str,
+	length: size
+};

rope/node.ha

···
+export type Node = (str | Rope);
+
+fn strtonode(data: str) Node = {
+	return data;
+};
+
+fn nodetorope(node: *Node) Rope = {
+	return Rope {
+		left = node,
+		right = null,
+		length = node_length(node)
+	};
+};
+
+fn node_length(node: *Node) size = {
+	return match (*node) {
+	case let leaf: str => yield len(leaf);
+	case let rope: Rope => yield rope_length(&rope);
+	};
+};

rope/rope.ha

···
+use fmt;
+
+export type indexerror = !void;
+
+export type Rope = struct {
+	left: nullable *Node,
+	right: nullable *Node,
+	length: size,
+};
+
+fn ropetonode(n: *Rope) *Node = {
+	return n: *Node;
+};
+
+
+fn rope_length(rope: *Rope) size = {
+	return rope.length + match (rope.right) {
+		case null => yield 0: size;
+		case let good: *Node => yield match (*good) {
+			case let leaf: str => yield len(leaf);
+			case let rop: Rope => yield rope_length(&rop);
+		};
+	};
+};
+
+export fn new(string: str) Rope = {
+	let node = strtonode(string);
+	return nodetorope(&node);
+};
+
+//fn create_node(l: nullable* Node, r: nullable* Node) Rope = {
+//	return Rope {
+//		left = l,
+//		right = r,
+//		length = match (l) {
+//		case null => yield 0;
+//		case let good: *Node => yield match (*good) {
+//			case let leaf: Leaf => yield leaf.length;
+//			case let node: Rope => yield rope_length(node);
+//			};
+//		}
+//	};
+//};
+
+export fn print(rope: *Rope) void = {
+	match (rope.left) {
+	case null => fmt::print("")!;
+	case let good: *Node => match (*good) {
+		case let leaf: str => fmt::print(leaf)!;
+		case let rope: Rope => print(&rope);
+		};
+	};
+
+	match (rope.right) {
+	case null => fmt::print("")!;
+	case let good: *Node => match (*good) {
+		case let leaf: str => fmt::print(leaf)!;
+		case let rope: Rope => print(&rope);
+		};
+	};
+};
+
+export fn println(rope: *Rope) void = {
+	print(rope);
+	fmt::println("")!;
+};
+
+//export fn index(rope: Rope, idx: size) (rune | indexerror) = {
+//	return if (idx >= rope.length) {
+//		yield match (rope.right) {
+//		case null => return indexerror;
+//		case let good: *Node => yield match (*good) {
+//			case let leaf: Leaf => yield strings::torunes(leaf.string)[idx - rope.length];
+//			case let rop: Rope => yield index(rop, idx - rope.length);
+//			};
+//		};
+//	} else {
+//		yield match (rope.left) {
+//		case null => return indexerror;
+//		case let good: *Node => yield match (*good) {
+//			case let leaf: Leaf => yield strings::torunes(leaf.string)[idx];
+//			case let rop: Rope => yield index(rop, idx);
+//			};
+//		};
+//	};
+//};
+
+export fn concat(l: *Rope, r: *Rope) Rope = {
+	return Rope {
+		left = &(*l: Node),
+		right = &(*r: Node),
+		length = rope_length(l),
+	};
+};

src/main.ha

···
-use fmt;
-use strconv;
-use strings;
-
-type indexerror = !void;
-
-type RefString = struct {
-	data: str,
-	ref_count: size
-};
-
-type Leaf = struct {
-	string: str,
-	length: size
-};
-
-// weight = length(left) + all_of(length(left.right))
-type Node = struct {
-	left: nullable *(Leaf | Node),
-	right: nullable *(Leaf | Node),
-	length: size,
-};
-
-type Rope = Node;
-
-fn s1(data: str) (Leaf | Node) = {
-	return Leaf {
-		string = data,
-		length = len(data)
-	};
-};
-
-fn n1(n: Node) (Leaf | Node) = {
-	return n;
-};
-
-fn r1(n: Node) Rope = {
-	return n;
-};
-
-fn combined_length(leaf: nullable* Node) size = {
-	return match (leaf) {
-	case null => yield 0: size;
-	case let good: *Node => yield good.length +
-		match (good.right) {
-		case null => yield 0: size;
-		case let good_right: *(Leaf | Node) => yield
-			match (*good_right) {
-			case let leaf: Leaf => yield leaf.length;
-			case let node: Node => yield combined_length(&node);
-			};
-		};
-	};
-};
-
-fn create_node(l: nullable* (Leaf | Node), r: nullable* (Leaf | Node)) Node = {
-	return Node {
-		left = l,
-		right = r,
-		length = match (l) {
-		case null => yield 0;
-		case let good: *(Leaf | Node) => yield
-			match (*good) {
-			case let leaf: Leaf => yield leaf.length;
-			case let node: Node => yield combined_length(&node);
-			};
-		}
-	};
-};
-
-fn create_rope(n: Node) Rope = {
-	return n;
-};
-
-//----- Operations -----//
-fn index(rope: Rope, idx: size) (rune | indexerror) = {
-	return if (idx >= rope.length) {
-		yield match (rope.right) {
-		case null => return indexerror;
-		case let good: *(Leaf | Node) => yield match (*good) {
-			case let leaf: Leaf => yield strings::torunes(leaf.string)[idx - rope.length];
-			case let node: Node => yield index(r1(node), idx - rope.length);
-			};
-		};
-	} else {
-		yield match (rope.left) {
-		case null => return indexerror;
-		case let good: *(Leaf | Node) => yield match (*good) {
-			case let leaf: Leaf => yield strings::torunes(leaf.string)[idx];
-			case let node: Node => yield index(r1(node), idx);
-		};
-	};
-};
+use rope::*;
 
 export fn main() void = {
-	let test = ["Hello ", "my ", "na", "me i", "s", " Simon"];
-	let e = s1(test[0]);
-	let f = s1(test[1]);
-	let j = s1(test[2]);
-	let k = s1(test[3]);
-	let m = s1(test[4]);
-	let n = s1(test[5]);
-	let c = create_node(&e, &f);
-	let g = create_node(&j, &k);
-	let h = create_node(&m, &n);
-	let d = create_node(&n1(g), &n1(h));
-	let b = create_node(&n1(c), &n1(d));
-	let a = create_node(&n1(b), null);
-	let my_rope = create_rope(a);
-	fmt::println("Hello world!")!;
-	fmt::println(index(a, 21)!)!;
+	let hello = new("hello ");
+	let world = new("world!");
+	let hello_world = concat(&hello, &world);
+	println(&hello_world);
 };