feat: improve printing values

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- improved printing of values
+- stdlib: `Variable` now moved to `rx.Variable`
 - stdlib: `osEnv` and `osExit` now moved to `os.env` and `os.exit`
 - compiler: `extern` fails when they can't be resolved
 

examples/syntax.lithia

@@ -1,4 +1,5 @@
 import tests
+import rx
 
 let a = 1
 
@@ -18,7 +19,7 @@ func just { x => Some x }
 just 1
 just 1
 
-let x Variable 1
+let x rx.Variable 1
 x.accept "Hallo"
 print x.current
 

interpreter/binary-operators.go

@@ -214,7 +214,7 @@ func (ex *EvaluationContext) lazyLogicComparision(
 	boolTypeValue, err := ex.environment.LookupRuntimeValue("Bool")
 	boolType := RuntimeType{
 		name:       "Bool",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 		typeValue:  &boolTypeValue,
 	}
 	if err != nil {
@@ -226,7 +226,7 @@ func (ex *EvaluationContext) lazyLogicComparision(
 	}
 	trueType := RuntimeType{
 		name:       "True",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 		typeValue:  &trueTypeValue,
 	}
 	if ok, err := boolType.IncludesValue(left); !ok || err != nil {

interpreter/extern-prelude.go

@@ -18,8 +18,6 @@ func (e ExternalPrelude) Lookup(name string, env *Environment) (RuntimeValue, bo
 		return PreludeRune(0).RuntimeType(), true
 	case "Function":
 		return PreludeFunctionType{}, true
-	case "Variable":
-		return PreludeVariableType{}, true
 	case "Module":
 		return PreludeModuleType{}, true
 	case "Any":

interpreter/extern-rx.go

@@ -0,0 +1,14 @@
+package interpreter
+
+var _ ExternalDefinition = ExternalRx{}
+
+type ExternalRx struct{}
+
+func (e ExternalRx) Lookup(name string, env *Environment) (RuntimeValue, bool) {
+	switch name {
+	case "Variable":
+		return RxVariableType{}, true
+	default:
+		return nil, false
+	}
+}

interpreter/interpreter.go

@@ -54,6 +54,7 @@ func NewInterpreter(importRoots ...string) *Interpreter {
 	}
 	inter.ExternalDefinitions["prelude"] = ExternalPrelude{}
 	inter.ExternalDefinitions["os"] = ExternalOS{}
+	inter.ExternalDefinitions["rx"] = ExternalRx{}
 	return inter
 }
 

interpreter/runtime.go

@@ -1,21 +1,29 @@
 package interpreter
 
 import (
+	"fmt"
 	"reflect"
 	"sync"
 )
 
 type RuntimeValue interface {
 	RuntimeType() RuntimeType
 	Lookup(name string) (*LazyRuntimeValue, error)
+	String() string
 }
 
+var _ RuntimeValue = RuntimeType{}
+
 type RuntimeType struct {
 	name       string
-	modulePath []string
+	moduleName ModuleName
 	typeValue  *RuntimeValue
 }
 
+func (t RuntimeType) String() string {
+	return fmt.Sprintf("%s.%s", t.moduleName, t.name)
+}
+
 func (t RuntimeType) RuntimeTypeValue() RuntimeValue {
 	if t.typeValue == nil {
 		return t.RuntimeType()

interpreter/type-any-type.go

@@ -11,10 +11,14 @@ type PreludeAnyType struct{}
 func (PreludeAnyType) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Any",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 
+func (a PreludeAnyType) String() string {
+	return "Any"
+}
+
 func (a PreludeAnyType) Lookup(member string) (*LazyRuntimeValue, error) {
 	return nil, fmt.Errorf("any type %s has no member %s", a, member)
 }

interpreter/type-enum-decl.go

@@ -1,6 +1,9 @@
 package interpreter
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 var _ RuntimeValue = EnumDeclRuntimeValue{}
 
@@ -9,6 +12,14 @@ type EnumDeclRuntimeValue struct {
 	cases map[string]*LazyRuntimeValue
 }
 
+func (e EnumDeclRuntimeValue) String() string {
+	cases := make([]string, 0, len(e.cases))
+	for key := range e.cases {
+		cases = append(cases, key)
+	}
+	return fmt.Sprintf("enum %s { %s }", e.name, strings.Join(cases, ", "))
+}
+
 func (EnumDeclRuntimeValue) RuntimeType() RuntimeType {
 	return PreludeAnyType{}.RuntimeType()
 }

interpreter/type-module-type.go

@@ -1,15 +1,21 @@
 package interpreter
 
-import "fmt"
+import (
+	"fmt"
+)
 
 var _ RuntimeValue = PreludeModuleType{}
 
 type PreludeModuleType struct{}
 
+func (PreludeModuleType) String() string {
+	return "Module"
+}
+
 func (PreludeModuleType) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Module",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-module.go

@@ -8,6 +8,10 @@ type RuntimeModule struct {
 	module *Module
 }
 
+func (m RuntimeModule) String() string {
+	return fmt.Sprintf("(import %s)", m.module.name)
+}
+
 func (RuntimeModule) RuntimeType() RuntimeType {
 	return PreludeModuleType{}.RuntimeType()
 }

interpreter/type-prelude-float.go

@@ -6,10 +6,14 @@ var _ RuntimeValue = PreludeFloat(0)
 
 type PreludeFloat float64
 
+func (f PreludeFloat) String() string {
+	return fmt.Sprintf("%f", f)
+}
+
 func (PreludeFloat) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Float",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-prelude-function-type.go

@@ -6,10 +6,14 @@ var _ RuntimeValue = PreludeFunctionType{}
 
 type PreludeFunctionType struct{}
 
+func (f PreludeFunctionType) String() string {
+	return "Function"
+}
+
 func (PreludeFunctionType) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Function",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-prelude-int.go

@@ -6,10 +6,14 @@ var _ RuntimeValue = PreludeInt(0)
 
 type PreludeInt int64
 
+func (i PreludeInt) String() string {
+	return fmt.Sprintf("%d", i)
+}
+
 func (PreludeInt) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Int",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-prelude-rune.go

@@ -6,10 +6,14 @@ var _ RuntimeValue = PreludeRune('l')
 
 type PreludeRune rune
 
+func (r PreludeRune) String() string {
+	return string(r)
+}
+
 func (PreludeRune) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "Rune",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-prelude-string.go

@@ -6,10 +6,14 @@ var _ RuntimeValue = PreludeString("")
 
 type PreludeString string
 
+func (s PreludeString) String() string {
+	return string(s)
+}
+
 func (PreludeString) RuntimeType() RuntimeType {
 	return RuntimeType{
 		name:       "String",
-		modulePath: []string{"prelude"},
+		moduleName: "prelude",
 	}
 }
 

interpreter/type-rx-variable-type.go

@@ -0,0 +1,38 @@
+package interpreter
+
+import (
+	"fmt"
+	"sync"
+)
+
+var _ RuntimeValue = RxVariableType{}
+var _ Callable = &RxVariableType{}
+
+type RxVariableType struct{}
+
+func (v RxVariableType) String() string {
+	return v.RuntimeType().String()
+}
+
+func (RxVariableType) RuntimeType() RuntimeType {
+	return RuntimeType{
+		name:       "Variable",
+		moduleName: "rx",
+	}
+}
+
+func (v RxVariableType) Lookup(member string) (*LazyRuntimeValue, error) {
+	return nil, fmt.Errorf("variable type %s has no member %s", v, member)
+}
+
+func (v RxVariableType) Call(arguments []*LazyRuntimeValue) (RuntimeValue, error) {
+	var _ Callable = v
+	if len(arguments) != 1 {
+		return nil, fmt.Errorf("too many arguments for variable type %s", v)
+	}
+	value, err := arguments[0].Evaluate()
+	if err != nil {
+		return nil, err
+	}
+	return &RuntimeVariable{current: value, lock: &sync.RWMutex{}}, nil
+}

interpreter/type-variable.go → interpreter/type-rx-variable.go

@@ -12,8 +12,14 @@ type RuntimeVariable struct {
 	current RuntimeValue
 }
 
+func (v *RuntimeVariable) String() string {
+	v.lock.RLock()
+	defer v.lock.RUnlock()
+	return fmt.Sprintf("(%s %s)", v.RuntimeType().name, v.current)
+}
+
 func (*RuntimeVariable) RuntimeType() RuntimeType {
-	return PreludeVariableType{}.RuntimeType()
+	return RxVariableType{}.RuntimeType()
 }
 
 func (v *RuntimeVariable) Lookup(member string) (*LazyRuntimeValue, error) {

stdlib/expect/fail.lithia

@@ -1,5 +1,6 @@
 module expect
 
 import tests
+import rx
 
-let fail = Variable tests.fail
+let fail = rx.Variable tests.fail

stdlib/prelude/shim.lithia

@@ -11,9 +11,5 @@ extern String {
 }
 extern Rune
 extern Function
-extern Variable {
-    accept value
-    current
-}
 extern Module
 extern Any

stdlib/rx/variable.lithia

@@ -0,0 +1,6 @@
+module rx
+
+extern Variable {
+    accept value
+    current
+}