Play around with a vector typeHEADmaster

Using _vectors_ as fundamental datatype could make for a really neat experience.

Imagine e.g.:

* fundamental arithmetic operations that apply to both vectors and scalars
* implicit component-wise or vector-wise operations
* scalar values as 1D vectors
* higher order functions to manipulate those vectors
    * `map` function that applies a (quoted?) word to all vector elements and returns the result
    * efficient parallel operations
* a rich library of vector manipulation functions
* or even: matrices as a fundamental datatype?
    * problem: probably harder to conveniently enter via a 1-D repl
* sound more and more like a RPN version of APL…

Back to reality, here is what this prototype actually adds:

* new `DList!int` based datatype alongside the existing int, string and bool types
* basic support for printing such values in a readable fashion
* new fundamental `:` word that constructs a vector of two elements
    * `1 2 :` yields `[1, 2]`
* adapted `+` and `*` to support component-wise operations
    * `1 2 : 3 +` yields `[4, 5]`

2 files changed, 31 insertions, 10 deletions

diff --git a/source/primitives/conditional.d b/source/primitives/conditional.d
index fd101bd..62a9fc5 100644
--- a/source/primitives/conditional.d
+++ b/source/primitives/conditional.d
@@ -19,7 +19,8 @@ bool handle(Token token) {
 	return token.visit!(
 		(int        ) => capture(token),
 		(bool       ) => capture(token),
-		(string word) => handle(word)
+		(string word) => handle(word),
+		(DList!int  ) => capture(token)
 	);
 }
 
diff --git a/source/primitives/core.d b/source/primitives/core.d
index 46ed890..7a13606 100644
--- a/source/primitives/core.d
+++ b/source/primitives/core.d
@@ -2,6 +2,8 @@ module primitives.core;
 
 import std.stdio;
 import std.variant;
+import std.conv : to;
+import std.algorithm : map;
 
 import state.stack;
 
@@ -9,7 +11,8 @@ bool handle(Token token) {
 	return token.visit!(
 		(int        ) => false,
 		(bool       ) => false,
-		(string word) => handle(word)
+		(string word) => handle(word),
+		(DList!int  ) => false
 	);
 }
 
@@ -25,7 +28,8 @@ bool handle(string word) {
 		case     "pop"   : unary_op_stack_pop;           break;
 		case     "dup"   : unary_op_stack_dup;           break;
 		case     "swp"   : binary_op_stack_swp;          break;
-		case     "ovr"   : binary_op_stack_ovr;         break;
+		case     "ovr"   : binary_op_stack_ovr;          break;
+		case     ":"     : binary_op_vector_cons;        break;
 		case     "rot"   : ternary_op_stack_rot;         break;
 		case     "true"  : nullary_op_value_bool(true);  break;
 		case     "false" : nullary_op_value_bool(false); break;
@@ -43,16 +47,18 @@ bool handle(string word) {
 
 void binary_op_add() {
 	int b = stack.pop.get!int;
-	int a = stack.pop.get!int;
-
-	stack.push(a + b);
+	stack.pop.tryVisit!(
+		(int a)       => stack.push(a + b),
+		(DList!int v) => stack.push(v[].map!(x => x + b).to!(DList!int))
+	);
 }
 
 void binary_op_multiply() {
 	int b = stack.pop.get!int;
-	int a = stack.pop.get!int;
-
-	stack.push(a * b);
+	stack.pop.tryVisit!(
+		(int a)       => stack.push(a * b),
+		(DList!int v) => stack.push(v[].map!(x => x * b).to!(DList!int))
+	);
 }
 
 void binary_op_divide() {
@@ -77,8 +83,22 @@ void binary_op_modulo() {
 	}
 }
 
+void binary_op_vector_cons() {
+	int b = stack.pop.get!int;
+
+	stack.pop.tryVisit!(
+		(int       a) => stack.push(DList!int(a, b)),
+		(DList!int v) => stack.push(v ~ b)
+	);
+}
+
 void unary_op_io_print() {
-	writeln(stack.top);
+	stack.top.visit!(
+		(int       x) => writeln(x),
+		(bool      b) => writeln(b),
+		(string word) => writeln(word),
+		(DList!int v) => writeln(v[])
+	);
 }
 
 void unary_op_stack_pop() {