switched typeof for oftype, switched typeas for astype

docs/TODO.txt

@@ -31,7 +31,7 @@ DONE: are compounds shallow or deep copies? Deep copies
 DONE: third output stream, for lexer/parser/compiler/interpreter errors
 DONE: Assertion-based test scripts
 DONE: Import/export keywords
-DONE: A way to check the type of a variable (typeOf keyword)
+DONE: A way to check the type of a variable (oftype keyword)
 DONE: slice and dot notation around the builtin _index and _dot functions
 
 

docs/spec.md

@@ -24,6 +24,7 @@ The following list of keywords cannot be used as names, due to their significanc
 
 * any
 * as
+* astype
 * assert
 * bool
 * break
@@ -44,13 +45,12 @@ The following list of keywords cannot be used as names, due to their significanc
 * int
 * null
 * of
+* oftype
 * print
 * return
 * string
 * true
 * type
-* typeas
-* typeof
 * var
 * while
 
@@ -118,11 +118,11 @@ var t: type = int;
 var u: t = 42;
 ```
 
-To force a type instead of an array, use the `typeas` keyword:
+To force a type instead of an array, use the `astype` keyword:
 
 ```
-var a = [typeas type]; //array of types
-var b = typeas [type]; //type of array of types
+var a = [type]; //array containing the type "type"
+var b = astype [type]; //type of array of types
 
 var d = b; //types can be re-assigned to other variables
 ```

scripts/example.toy

@@ -72,7 +72,7 @@ print [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
 var x = 31;
 var y : int = 42;
 var arr : [int] = [1, 2, 3, 42];
-var dict : [string, int] = ["hello": 1, "world":2];
+var dict : [string:int] = ["hello": 1, "world":2];
 
 //printing expressions
 print x;

scripts/small.toy

@@ -2,14 +2,14 @@
 
 
 
-var t: type = typeas [int];
-var u: type = typeas [t];
+var t: type = astype [int];
+var u: type = astype [t];
 
 var a: u;
 
-t = typeas [float]; //redefnition
+t = astype [float]; //redefnition
 
 var b: u;
 
-print typeof a; //<[<int>]>
-print typeof b; //<[<float>]>
+print oftype a; //<[<int>]>
+print oftype b; //<[<float>]>

scripts/test/imports-and-exports.toy

@@ -32,7 +32,7 @@
 	assert func() == 69, "import/export of functions failed";
 }
 
-//test that variables retain their types with the typeof keyword
+//test that variables retain their types with the oftype keyword
 {
 	var t: type = int;
 
@@ -42,7 +42,7 @@
 {
 	import t;
 
-	assert typeof t == type, "type retention failed";
+	assert oftype t == type, "type retention failed";
 }
 
 print "All good";

scripts/test/types.toy

@@ -7,15 +7,15 @@ assert u == 42, "first-class types are screwing with values";
 
 
 //differentiate by the "type" value
-var v: type = typeas [int];
+var v: type = astype [int];
 var w = [int];
 var x = v;
 
 assert w == [int], "defining an array of types failed";
-assert x == typeas [int], "re-assigning a type value failed";
+assert x == astype [int], "re-assigning a type value failed";
 
 //complex type
-var complex: type = typeas [string : [int]];
+var complex: type = astype [string : [int]];
 var dict: complex = [
 	"first array": [1, 2, 3],
 	"second array": [4, 5, 6],

source/keyword_types.c

@@ -33,8 +33,8 @@ KeywordType keywordTypes[] = {
 	{TOKEN_PRINT,      "print"},
 	{TOKEN_RETURN,     "return"},
 	{TOKEN_TYPE,       "type"},
-	{TOKEN_TYPEAS,     "typeas"},
-	{TOKEN_TYPEOF,     "typeof"},
+	{TOKEN_ASTYPE,     "astype"},
+	{TOKEN_OFTYPE,     "oftype"},
 	{TOKEN_VAR,        "var"},
 	{TOKEN_WHILE,      "while"},
 

source/parser.c

@@ -120,11 +120,11 @@ static void parsePrecedence(Parser* parser, Node** nodeHandle, PrecedenceRule ru
 static Literal readTypeToLiteral(Parser* parser);
 
 //the expression rules
-static Opcode typeAs(Parser* parser, Node** nodeHandle) {
+static Opcode asType(Parser* parser, Node** nodeHandle) {
 	Literal literal = readTypeToLiteral(parser);
 
 	if (!IS_TYPE(literal)) {
-		error(parser, parser->previous, "Expected type after 'typeas' keyword");
+		error(parser, parser->previous, "Expected type after 'astype' keyword");
 		freeLiteral(literal);
 		return OP_EOF;
 	}
@@ -136,7 +136,7 @@ static Opcode typeAs(Parser* parser, Node** nodeHandle) {
 	return OP_EOF;
 }
 
-static Opcode typeOf(Parser* parser, Node** nodeHandle) {
+static Opcode ofType(Parser* parser, Node** nodeHandle) {
 	Node* rhs = NULL;
 	parsePrecedence(parser, &rhs, PREC_TERNARY);
 	emitNodeUnary(nodeHandle, OP_TYPE_OF, rhs);
@@ -820,8 +820,8 @@ ParseRule parseRules[] = { //must match the token types
 	{NULL, NULL, PREC_NONE},// TOKEN_PRINT,
 	{NULL, NULL, PREC_NONE},// TOKEN_RETURN,
 	{atomic, NULL, PREC_NONE},// TOKEN_TYPE,
-	{typeAs, NULL, PREC_PRIMARY},// TOKEN_TYPEAS,
-	{typeOf, NULL, PREC_CALL},// TOKEN_TYPEOF,
+	{asType, NULL, PREC_PRIMARY},// TOKEN_ASTYPE,
+	{ofType, NULL, PREC_CALL},// TOKEN_OFTYPE,
 	{NULL, NULL, PREC_NONE},// TOKEN_VAR,
 	{NULL, NULL, PREC_NONE},// TOKEN_WHILE,
 

source/token_types.h

@@ -31,8 +31,8 @@ typedef enum TokenType {
 	TOKEN_PRINT,
 	TOKEN_RETURN,
 	TOKEN_TYPE,
-	TOKEN_TYPEAS,
-	TOKEN_TYPEOF,
+	TOKEN_ASTYPE,
+	TOKEN_OFTYPE,
 	TOKEN_VAR,
 	TOKEN_WHILE,
 

test/sample_code.toy

@@ -1,8 +1,8 @@
 
 
 
-var complex: type = typeas [string: [int]];
-var deep: type = typeas [[[ int ]]];
+var complex: type = astype [string: [int]];
+var deep: type = astype [[[ int ]]];