Custom types

README.md

@@ -30,20 +30,44 @@ Supported variable types are *bool*, *int*, *string* and *error*.
 ```golang
 // Variable definition with default value.
 var a int
-var a, b int
+var b, c int
 ```
 
 ```golang
 // Variable definition with assigned value.
 var a int = 5
-var a, b int = divisionWithRemainder(5, 2)
+var b, c int = divisionWithRemainder(5, 2)
+```
+
+```golang
+// Variable definition via grouping.
+var (
+    a = 5
+    b, c int = divisionWithRemainder(5, 2)
+)
 ```
 
 ```golang
 // Variable definition short form.
 a := 5
-a, b := 5, 6
-a, b := divisionWithRemainder(5, 2)
+b, c := 5, 6
+d, e := divisionWithRemainder(5, 2)
+```
+
+### Constants
+```golang
+// Constant definition.
+const a = 0
+const b, c = 1, 2
+```
+
+```golang
+// Constant definition via grouping.
+const (
+    a = -1
+    b = iota
+    c
+)
 ```
 
 ### Control flow
@@ -196,6 +220,25 @@ import (
 print(strings.Contains("Hello World", "World")) // Prints 1.
 ```
 
+### Type declarations
+TypeShell supports the declaration of types. However, types which result in slices are not supported yet.
+
+```golang
+// Define a type.
+type myType int
+
+var a myType
+a = myType(24)
+```
+
+```golang
+// Define an alias.
+type myType = int
+
+var a myType
+a = 24
+```
+
 ### Builtin
 ```golang
 // Returns the length of a slice or a string.

lexer/lexer.go

@@ -42,9 +42,6 @@ const (
 	STRING_LITERAL
 	NIL_LITERAL
 
-	// Types.
-	DATA_TYPE
-
 	// Separators.
 	COMMA
 	COLON
@@ -58,6 +55,8 @@ const (
 
 	// Keywords.
 	IMPORT
+	TYPE_DECLARATION
+	CONST_DEFINITION
 	VAR_DEFINITION
 	FUNCTION_DEFINITION
 	RETURN
@@ -70,6 +69,7 @@ const (
 	RANGE
 	BREAK
 	CONTINUE
+	IOTA
 
 	// Builtin functions.
 	LEN
@@ -90,13 +90,6 @@ const (
 	EOF
 )
 
-const (
-	DATA_TYPE_BOOLEAN VarType = "bool"
-	DATA_TYPE_INTEGER VarType = "int"
-	DATA_TYPE_STRING  VarType = "string"
-	DATA_TYPE_ERROR   VarType = "error"
-)
-
 type Token struct {
 	tokenType TokenType
 	value     string
@@ -180,6 +173,8 @@ var nonAlphabeticTokens = []tokenMapping{
 var keywords = map[string]TokenType{
 	// Common keywords.
 	"import":   IMPORT,
+	"type":     TYPE_DECLARATION,
+	"const":    CONST_DEFINITION,
 	"var":      VAR_DEFINITION,
 	"func":     FUNCTION_DEFINITION,
 	"return":   RETURN,
@@ -192,6 +187,7 @@ var keywords = map[string]TokenType{
 	"range":    RANGE,
 	"break":    BREAK,
 	"continue": CONTINUE,
+	"iota":     IOTA,
 	"nil":      NIL_LITERAL,
 
 	// Builtin functions.
@@ -204,12 +200,6 @@ var keywords = map[string]TokenType{
 	"read":   READ,
 	"write":  WRITE,
 	"panic":  PANIC,
-
-	// Types.
-	DATA_TYPE_BOOLEAN: DATA_TYPE,
-	DATA_TYPE_INTEGER: DATA_TYPE,
-	DATA_TYPE_STRING:  DATA_TYPE,
-	DATA_TYPE_ERROR:   DATA_TYPE,
 }
 
 func newToken(value string, tokenType TokenType, row int, column int) Token {

parser/appcall.go

@@ -14,6 +14,10 @@ func (a AppCall) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_MULTIPLE, false)
 }
 
+func (a AppCall) IsConstant() bool {
+	return false
+}
+
 func (a AppCall) Name() string {
 	return a.name
 }

parser/assignment.go

@@ -0,0 +1,6 @@
+package parser
+
+type Assignment interface {
+	Statement
+	AssignmentType() AssignmentType
+}

parser/binaryoperation.go

@@ -1,9 +1,9 @@
 package parser
 
 type BinaryOperation struct {
-	left      Expression
-	operator  BinaryOperator
-	right     Expression
+	left     Expression
+	operator BinaryOperator
+	right    Expression
 }
 
 func (b BinaryOperation) StatementType() StatementType {
@@ -14,6 +14,10 @@ func (b BinaryOperation) ValueType() ValueType {
 	return b.left.ValueType()
 }
 
+func (b BinaryOperation) IsConstant() bool {
+	return b.Left().IsConstant() && b.Right().IsConstant()
+}
+
 func (b BinaryOperation) Left() Expression {
 	return b.left
 }

parser/comparison.go

@@ -22,6 +22,10 @@ func (c Comparison) ValueType() ValueType {
 	return ValueType{dataType: DATA_TYPE_BOOLEAN}
 }
 
+func (c Comparison) IsConstant() bool {
+	return c.Left().IsConstant() && c.Right().IsConstant()
+}
+
 func (c Comparison) Left() Expression {
 	return c.left
 }

parser/const.go

@@ -0,0 +1,70 @@
+package parser
+
+type Const struct {
+	name      string
+	valueType ValueType
+	global    bool
+	public    bool
+}
+
+func NewConst(name string, valueType ValueType, global bool, public bool) Const {
+	return Const{
+		name,
+		valueType,
+		global,
+		public,
+	}
+}
+
+func (c Const) Name() string {
+	return c.name
+}
+
+func (c Const) ValueType() ValueType {
+	return c.valueType
+}
+
+func (c Const) IsConstant() bool {
+	return true
+}
+
+func (c *Const) SetValueType(valueType ValueType) {
+	c.valueType = valueType
+}
+
+func (c Const) Global() bool {
+	return c.global
+}
+
+func (c Const) Public() bool {
+	return c.public
+}
+
+type ConstDefinition struct {
+	constants []Const
+	values    []Expression
+}
+
+func (c ConstDefinition) StatementType() StatementType {
+	return STATEMENT_TYPE_CONST_DEFINITION
+}
+
+func (c ConstDefinition) AssignmentType() AssignmentType {
+	return ASSIGNMENT_TYPE_VALUE
+}
+
+func (c ConstDefinition) Constants() []Const {
+	return c.constants
+}
+
+func (c ConstDefinition) Values() []Expression {
+	return c.values
+}
+
+type ConstEvaluation struct {
+	Const
+}
+
+func (c ConstEvaluation) StatementType() StatementType {
+	return STATEMENT_TYPE_CONST_EVALUATION
+}

parser/copy.go

@@ -13,6 +13,10 @@ func (c Copy) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_INTEGER, false)
 }
 
+func (c Copy) IsConstant() bool {
+	return false
+}
+
 func (c Copy) Source() Expression {
 	return c.source
 }

parser/exists.go

@@ -12,6 +12,10 @@ func (e Exists) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_BOOLEAN, false)
 }
 
+func (e Exists) IsConstant() bool {
+	return false
+}
+
 func (e Exists) Path() Expression {
 	return e.path
 }

parser/expression.go

@@ -4,4 +4,5 @@ type Expression interface {
 	// An expression is a super-type of statement which results in a value.
 	Statement
 	ValueType() ValueType
+	IsConstant() bool
 }

parser/function.go

@@ -20,6 +20,10 @@ func (e FunctionDefinition) ValueType() ValueType {
 	return functionValueType(e.returnTypes)
 }
 
+func (e FunctionDefinition) IsConstant() bool {
+	return false
+}
+
 func (e FunctionDefinition) ReturnTypes() []ValueType {
 	return e.returnTypes
 }
@@ -54,6 +58,10 @@ func (e FunctionCall) ValueType() ValueType {
 	return functionValueType(e.returnTypes)
 }
 
+func (e FunctionCall) IsConstant() bool {
+	return false
+}
+
 func (e FunctionCall) ReturnTypes() []ValueType {
 	return e.returnTypes
 }

parser/group.go

@@ -12,6 +12,10 @@ func (e Group) ValueType() ValueType {
 	return e.Child().ValueType()
 }
 
+func (e Group) IsConstant() bool {
+	return e.Child().IsConstant()
+}
+
 func (e Group) Child() Expression {
 	return e.child
 }

parser/input.go

@@ -12,6 +12,10 @@ func (i Input) ValueType() ValueType {
 	return ValueType{dataType: DATA_TYPE_STRING}
 }
 
+func (i Input) IsConstant() bool {
+	return false
+}
+
 func (i Input) Prompt() Expression {
 	return i.prompt
 }

parser/iota.go

@@ -0,0 +1,16 @@
+package parser
+
+type Iota struct {
+}
+
+func (i Iota) StatementType() StatementType {
+	return STATEMENT_TYPE_IOTA
+}
+
+func (i Iota) ValueType() ValueType {
+	return NewValueType(DATA_TYPE_INTEGER, false)
+}
+
+func (i Iota) IsConstant() bool {
+	return true
+}

parser/itoa.go

@@ -12,6 +12,10 @@ func (e Itoa) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_STRING, false)
 }
 
+func (o Itoa) IsConstant() bool {
+	return false
+}
+
 func (e Itoa) Value() Expression {
 	return e.value
 }

parser/len.go

@@ -12,6 +12,10 @@ func (l Len) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_INTEGER, false)
 }
 
+func (l Len) IsConstant() bool {
+	return false
+}
+
 func (l Len) Expression() Expression {
 	return l.expression
 }