shorten type names

core/compiler.go

@@ -195,6 +195,34 @@ 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,31 +1419,14 @@ func (p *Parser) parseSignature() (TypeSignature, error) {
 		name := (*p.prev).Lexeme
 
 		switch name {
-		case "string":
+		case "str":
 			s = &StringSignature{}
 		case "int":
 			s = &IntegerSignature{}
 		case "float":
 			s = &FloatSignature{}
-		case "boolean":
+		case "bool":
 			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,6 +470,26 @@ 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,3 +8,6 @@ assertEq([3, 1, 4, 1], [3, 1, 4, 1])
 
 # Inequality
 assertNotEq(2, 3)
+
+assert(1 < 2)
+assert(1.0 < 2.0)