core/compiler.go

@@ -195,34 +195,6 @@ func (c *Compiler) compile(tree Node) error {
 
 	switch tree.Type() {
 	case StringNodeType:
-		n := tree.(*StringNode)
-		s := ""
-		escaped := false
-
-		for _, ch := range n.value {
-			if escaped {
-				switch ch {
-				case 'n':
-					s += "\n"
-				case 't':
-					s += "\t"
-				case 'r':
-					s += "\r"
-				default:
-					s += string(ch)
-				}
-				escaped = false
-				continue
-			}
-
-			switch ch {
-			case '\\':
-				escaped = true
-			default:
-				s += string(ch)
-			}
-		}
-
 		c.add(InstructionConstant)
 		c.addConstant(&StringValue{
 			tree.(*StringNode).value,

core/parser.go

@@ -1419,14 +1419,31 @@ func (p *Parser) parseSignature() (TypeSignature, error) {
 		name := (*p.prev).Lexeme
 
 		switch name {
-		case "str":
+		case "string":
 			s = &StringSignature{}
 		case "int":
 			s = &IntegerSignature{}
 		case "float":
 			s = &FloatSignature{}
-		case "bool":
+		case "boolean":
 			s = &BooleanSignature{}
+		case "list":
+			if err := p.expect(TokenOpenBracket, "list must have content typed"); err != nil {
+				return nil, err
+			}
+
+			contents, err := p.parseSignature()
+			if err != nil {
+				return nil, err
+			}
+
+			if err := p.expect(TokenCloseBracket, "square brackets enclose list content signature"); err != nil {
+				return nil, err
+			}
+
+			s = &ListSignature{
+				contents,
+			}
 
 		case "any":
 			s = &AnySignature{}

core/vm.go

@@ -470,26 +470,6 @@ var DefaultGlobals = map[string]Value{
 		nil,
 		true,
 	},
-	"assert": &BuiltinFunctionValue{
-		"assert",
-		&FunctionSignature{
-			[]TypeSignature{
-				&BooleanSignature{},
-			},
-			&NilSignature{},
-		},
-		func(vm *VM, this Value, params []Value) (Value, error) {
-			b := params[0].(*BoolValue)
-
-			if !b.Boolean {
-				return nil, errors.New(fmt.Sprintf("assertion failed: %s", b))
-			}
-
-			return &NilValue{}, nil
-		},
-		nil,
-		false,
-	},
 	"assertEq": &BuiltinFunctionValue{
 		"assertEq",
 		&FunctionSignature{

tests/conditions.ang

@@ -8,6 +8,3 @@ assertEq([3, 1, 4, 1], [3, 1, 4, 1])
 
 # Inequality
 assertNotEq(2, 3)
-
-assert(1 < 2)
-assert(1.0 < 2.0)