stdlib/compiler: alias imports, dicts #9 #32

- compiler: alias imports `import alias = module.name` #32
- compiler: dictionary literals `[:]` and `["a": "b"]` #9
- stdlib: new type `prelude.Dict` #9
- stdlib: new type `prelude.Pair`

Author: vknabel

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## v0.0.17-next
 
+- compiler: alias imports `import alias = module.name` #32
+- compiler: dictionary literals `[:]` and `["a": "b"]` #9
+- stdlib: new type `prelude.Dict` #9
+- stdlib: new type `prelude.Pair`
 - stdlib: Float-support! #24
 - stdlib: `!` operator #22
 

ast/decl-import.go

@@ -9,15 +9,15 @@ var _ Decl = DeclImport{}
 var _ Overviewable = DeclImport{}
 
 type DeclImport struct {
+	Alias      Identifier
 	ModuleName ModuleName
 	Members    []DeclImportMember
 
 	MetaInfo *MetaDecl
 }
 
 func (e DeclImport) DeclName() Identifier {
-	segments := strings.Split(string(e.ModuleName), ".")
-	return Identifier(segments[len(segments)-1])
+	return e.Alias
 }
 
 func (e DeclImport) DeclOverview() string {
@@ -37,7 +37,19 @@ func (e *DeclImport) AddMember(member DeclImportMember) {
 }
 
 func MakeDeclImport(name ModuleName, source *Source) *DeclImport {
+	segments := strings.Split(string(name), ".")
+	alias := Identifier(segments[len(segments)-1])
 	return &DeclImport{
+		Alias:      alias,
+		ModuleName: name,
+		Members:    make([]DeclImportMember, 0),
+		MetaInfo:   &MetaDecl{source},
+	}
+}
+
+func MakeDeclAliasImport(alias Identifier, name ModuleName, source *Source) *DeclImport {
+	return &DeclImport{
+		Alias:      alias,
 		ModuleName: name,
 		Members:    make([]DeclImportMember, 0),
 		MetaInfo:   &MetaDecl{source},

ast/expr-dict.go

@@ -0,0 +1,45 @@
+package ast
+
+var _ Expr = ExprDict{}
+
+type ExprDict struct {
+	Entries []ExprDictEntry
+
+	MetaInfo *MetaExpr
+}
+
+func (e ExprDict) Meta() *MetaExpr {
+	return e.MetaInfo
+}
+
+func MakeExprDict(entries []ExprDictEntry, source *Source) *ExprDict {
+	return &ExprDict{
+		Entries: entries,
+		MetaInfo: &MetaExpr{
+			Source: source,
+		},
+	}
+}
+
+func (e ExprDict) EnumerateNestedDecls(enumerate func(interface{}, []Decl)) {
+	for _, el := range e.Entries {
+		el.Key.EnumerateNestedDecls(enumerate)
+		el.Value.EnumerateNestedDecls(enumerate)
+	}
+}
+
+type ExprDictEntry struct {
+	Key      Expr
+	Value    Expr
+	MetaInfo *MetaExpr
+}
+
+func MakeExprDictEntry(key Expr, value Expr, source *Source) *ExprDictEntry {
+	return &ExprDictEntry{
+		Key:   key,
+		Value: value,
+		MetaInfo: &MetaExpr{
+			Source: source,
+		},
+	}
+}

parser/node-types.go

@@ -27,6 +27,8 @@ var (
 	TYPE_NODE_INT_LITERAL                   = "int_literal"
 	TYPE_NODE_FLOAT_LITERAL                 = "float_literal"
 	TYPE_NODE_ARRAY_LITERAL                 = "array_literal"
+	TYPE_NODE_DICT_LITERAL                  = "dict_literal"
+	TYPE_NODE_DICT_ENTRY                    = "dict_entry"
 	TYPE_NODE_FUNCTION_LITERAL              = "function_literal"
 	TYPE_NODE_PARAMETER_LIST                = "parameter_list"
 	TYPE_NODE_IDENTIFIER                    = "identifier"

parser/parse-decl-import.go

@@ -8,6 +8,7 @@ import (
 
 func (fp *FileParser) ParseImportDeclaration() (*ast.DeclImport, []SyntaxError) {
 	importModuleNode := fp.Node.ChildByFieldName("name")
+	aliasNode := fp.Node.ChildByFieldName("alias")
 	membersNode := fp.Node.ChildByFieldName("members")
 	var membersCount int
 	if membersNode == nil {
@@ -21,7 +22,13 @@ func (fp *FileParser) ParseImportDeclaration() (*ast.DeclImport, []SyntaxError)
 		modulePath = append(modulePath, importModuleNode.NamedChild(i).Content(fp.Source))
 	}
 	moduleName := ast.ModuleName(strings.Join(modulePath, "."))
-	importDecl := ast.MakeDeclImport(moduleName, fp.AstSource())
+
+	var importDecl *ast.DeclImport
+	if aliasNode == nil {
+		importDecl = ast.MakeDeclImport(moduleName, fp.AstSource())
+	} else {
+		importDecl = ast.MakeDeclAliasImport(ast.Identifier(aliasNode.Content(fp.Source)), moduleName, fp.AstSource())
+	}
 
 	for i := 0; i < membersCount; i++ {
 		child := membersNode.NamedChild(i)

parser/parse-expr-dict.go

@@ -0,0 +1,43 @@
+package parser
+
+import (
+	"github.com/vknabel/lithia/ast"
+)
+
+func (fp *FileParser) ParseExprDict() (*ast.ExprDict, []SyntaxError) {
+	numberOfEntries := int(fp.Node.NamedChildCount())
+	entries := make([]ast.ExprDictEntry, 0, numberOfEntries)
+	for i := 0; i < numberOfEntries; i++ {
+		entryNode := fp.Node.NamedChild(i)
+		if entryNode.Type() == TYPE_NODE_COMMENT {
+			fp.Comments = append(fp.Comments, entryNode.Content(fp.Source))
+			continue
+		}
+		entry, errs := fp.ChildParserConsumingComments(entryNode).parseExprDictEntry()
+		if len(errs) > 0 {
+			return nil, errs
+		}
+		if entry != nil {
+			entries = append(entries, *entry)
+		}
+	}
+	return ast.MakeExprDict(entries, fp.AstSource()), nil
+}
+
+func (fp *FileParser) parseExprDictEntry() (*ast.ExprDictEntry, []SyntaxError) {
+	keyNode := fp.Node.ChildByFieldName("key")
+	valueNode := fp.Node.ChildByFieldName("value")
+
+	keyP := fp.ChildParserConsumingComments(keyNode)
+	key, errs := keyP.ParseExpression()
+	if len(errs) > 0 {
+		return nil, errs
+	}
+
+	valueP := fp.ChildParserConsumingComments(valueNode)
+	value, errs := valueP.ParseExpression()
+	if len(errs) > 0 {
+		return nil, errs
+	}
+	return ast.MakeExprDictEntry(key, value, fp.AstSource()), nil
+}

parser/parse-expr.go

@@ -85,6 +85,13 @@ func (fp *FileParser) ParseExpressionIfGiven() (ast.Expr, []SyntaxError) {
 		} else {
 			return expr, errs
 		}
+	case TYPE_NODE_DICT_LITERAL:
+		expr, errs := fp.ParseExprDict()
+		if expr == nil {
+			return nil, errs
+		} else {
+			return expr, errs
+		}
 	case TYPE_NODE_FUNCTION_LITERAL:
 		expr, errs := fp.ParseFunctionExpr(fmt.Sprintf("func#%d", fp.CountFunction()))
 		if expr == nil {

runtime/environment-data.go

@@ -45,3 +45,18 @@ func (env *Environment) MakeEagerList(slice []RuntimeValue) (DataRuntimeValue, *
 		})
 	}
 }
+
+func (env *Environment) MakeSome(value Evaluatable) (DataRuntimeValue, *RuntimeError) {
+	return env.MakeDataRuntimeValue("Some", map[string]Evaluatable{
+		"value": value,
+	})
+}
+func (env *Environment) MakeNone() (DataRuntimeValue, *RuntimeError) {
+	return env.MakeEmptyDataRuntimeValue("None")
+}
+func (env *Environment) MakePair(key Evaluatable, value Evaluatable) (DataRuntimeValue, *RuntimeError) {
+	return env.MakeDataRuntimeValue("Pair", map[string]Evaluatable{
+		"key":   key,
+		"value": value,
+	})
+}

runtime/evaluatable-expr.go

@@ -41,6 +41,8 @@ func (e EvaluatableExpr) Evaluate() (RuntimeValue, *RuntimeError) {
 		switch expr := e.Expr.(type) {
 		case *ast.ExprArray:
 			return e.EvaluateExprArray(*expr)
+		case *ast.ExprDict:
+			return e.EvaluateExprDict(*expr)
 		case *ast.ExprFloat:
 			return e.EvaluateExprFloat(*expr)
 		case *ast.ExprFunc:
@@ -80,6 +82,22 @@ func (e EvaluatableExpr) EvaluateExprArray(expr ast.ExprArray) (RuntimeValue, *R
 	return list, err.CascadeExpr(expr)
 }
 
+func (e EvaluatableExpr) EvaluateExprDict(expr ast.ExprDict) (RuntimeValue, *RuntimeError) {
+	rawDict := make(map[PreludeString]Evaluatable)
+	for _, entry := range expr.Entries {
+		keyValue, err := MakeEvaluatableExpr(e.Context, entry.Key).Evaluate()
+		if err != nil {
+			return nil, err.CascadeExpr(expr)
+		}
+		if key, ok := keyValue.(PreludeString); ok {
+			rawDict[key] = MakeEvaluatableExpr(e.Context, entry.Value)
+		} else {
+			return nil, NewRuntimeErrorf("dict key must be a string, got %s", keyValue).CascadeExpr(expr)
+		}
+	}
+	return MakePreludeDict(e.Context, rawDict), nil
+}
+
 func (e EvaluatableExpr) EvaluateExprFloat(expr ast.ExprFloat) (RuntimeValue, *RuntimeError) {
 	return PreludeFloat(expr.Literal), nil
 }

runtime/external-prelude.go

@@ -39,6 +39,15 @@ func (e ExternalPrelude) Lookup(name string, env *Environment, decl ast.Decl) (R
 		} else {
 			return nil, false
 		}
+	case "Dict":
+		if externDecl, ok := decl.(ast.DeclExternType); ok {
+			return PreludePrimitiveExternType{&externDecl, func(value RuntimeValue) (bool, *RuntimeError) {
+				_, ok := value.(PreludeDict)
+				return ok, nil
+			}}, true
+		} else {
+			return nil, false
+		}
 	case "Char":
 		if externDecl, ok := decl.(ast.DeclExternType); ok {
 			return PreludePrimitiveExternType{&externDecl, func(value RuntimeValue) (bool, *RuntimeError) {

runtime/prelude-dict.go

@@ -0,0 +1,138 @@
+package runtime
+
+import (
+	"fmt"
+	"strings"
+)
+
+var _ RuntimeValue = PreludeDict{}
+var PreludeDictTypeRef = MakeRuntimeTypeRef("Dict", "prelude")
+
+type PreludeDict struct {
+	dict    map[PreludeString]Evaluatable
+	context *InterpreterContext
+}
+
+func MakePreludeDict(context *InterpreterContext, dict map[PreludeString]Evaluatable) PreludeDict {
+	copy := map[PreludeString]Evaluatable{}
+	for k, v := range dict {
+		copy[k] = v
+	}
+	return PreludeDict{
+		dict:    copy,
+		context: context,
+	}
+}
+
+func (PreludeDict) RuntimeType() RuntimeTypeRef {
+	return PreludeDictTypeRef
+}
+
+func (rv PreludeDict) String() string {
+	if len(rv.dict) == 0 {
+		return "[:]"
+	}
+	entries := []string{}
+	for k, v := range rv.dict {
+		value, err := v.Evaluate()
+		if err != nil {
+			entries = append(entries, fmt.Sprintf("%s: %s", k, err.Error()))
+		} else {
+			entries = append(entries, fmt.Sprintf("%s: %s", k, value))
+		}
+	}
+	return fmt.Sprintf("[%s]", strings.Join(entries, ", "))
+}
+
+func (rv PreludeDict) Lookup(member string) (Evaluatable, *RuntimeError) {
+	switch member {
+	case "length":
+		return NewConstantRuntimeValue(PreludeInt(len(rv.dict))), nil
+	case "get":
+		return NewConstantRuntimeValue(MakeAnonymousFunction(
+			"get",
+			[]string{"key"},
+			func(args []Evaluatable) (RuntimeValue, *RuntimeError) {
+				key, err := args[0].Evaluate()
+				if err != nil {
+					return nil, err
+				}
+				if key, ok := key.(PreludeString); ok {
+					if value, ok := rv.dict[key]; ok {
+						return rv.context.environment.MakeSome(value)
+					} else {
+						return rv.context.environment.MakeNone()
+					}
+				} else {
+					return nil, NewRuntimeErrorf("dict key must be a string, got %s", key)
+				}
+			})), nil
+	case "set":
+		return NewConstantRuntimeValue(MakeAnonymousFunction(
+			"set",
+			[]string{"key", "value"},
+			func(args []Evaluatable) (RuntimeValue, *RuntimeError) {
+				key, err := args[0].Evaluate()
+				if err != nil {
+					return nil, err
+				}
+
+				if key, ok := key.(PreludeString); ok {
+					copy := rv.copy()
+					copy.dict[key] = args[1]
+					return copy, nil
+				} else {
+					return nil, NewRuntimeErrorf("dict key must be a string, got %s", key)
+				}
+			})), nil
+	case "delete":
+		return NewConstantRuntimeValue(MakeAnonymousFunction(
+			"delete",
+			[]string{"key"},
+			func(args []Evaluatable) (RuntimeValue, *RuntimeError) {
+				key, err := args[0].Evaluate()
+				if err != nil {
+					return nil, err
+				}
+
+				if key, ok := key.(PreludeString); ok {
+					copy := rv.copy()
+					delete(copy.dict, key)
+					return copy, nil
+				} else {
+					return nil, NewRuntimeErrorf("dict key must be a string, got %s", key)
+				}
+			})), nil
+	case "entries":
+		pairs := make([]RuntimeValue, 0, len(rv.dict))
+		for k, v := range rv.dict {
+			pair, err := rv.context.environment.MakePair(NewConstantRuntimeValue(k), v)
+			if err != nil {
+				return nil, err
+			}
+			pairs = append(pairs, pair)
+		}
+		dataList, err := rv.context.environment.MakeEagerList(pairs)
+		return NewConstantRuntimeValue(dataList), err
+	case "keys":
+		keys := make([]RuntimeValue, 0, len(rv.dict))
+		for k := range rv.dict {
+			keys = append(keys, k)
+		}
+		dataList, err := rv.context.environment.MakeEagerList(keys)
+		return NewConstantRuntimeValue(dataList), err
+	case "values":
+		values := make([]Evaluatable, 0, len(rv.dict))
+		for _, v := range rv.dict {
+			values = append(values, v)
+		}
+		dataList, err := rv.context.environment.MakeList(values)
+		return NewConstantRuntimeValue(dataList), err
+	default:
+		return nil, NewRuntimeErrorf("no such member: %s", member)
+	}
+}
+
+func (rv PreludeDict) copy() PreludeDict {
+	return MakePreludeDict(rv.context, rv.dict)
+}