Adding map.key as short for map["key"] (#117)

* Adding map.key as short for map["key"]

* readme typo

* readme update for actual run

* fix for continuation needed in middle of expression like `map = {`

* fix precedence for dot notation

* new file missing

* Now show the info.all_ids stack as an array but each layer is a map with actual values (can get long/expensive though)

* Update examples/sample.gr

Co-authored-by: ccoVeille <[email protected]>

---------

Co-authored-by: ccoVeille <[email protected]>

Author: ldemailly

README.md

@@ -37,7 +37,7 @@ $ fact = func(n) {if (n<=1) {return 1} n*self(n-1)} // could be n*fact(n-1) too
 		return 1
 	}
 	n * self(n - 1)
-}
+} // could be n*fact(n-1) too
 == Eval  ==> func(n){if n<=1{return 1}n*self(n-1)}
 $ n=fact(6)
 == Parse ==> n = fact(6)
@@ -48,20 +48,20 @@ $ m=fact(7)
 $ m/n
 == Parse ==> m / n
 == Eval  ==> 7
-$ func fx(n) {if n>0 {return fx(n-1)}; info["all_ids"]}; fx(3)
+$ func fx(n) {if n>0 {return fx(n-1)}; info.all_ids}; fx(3)
 == Parse ==> func fx(n) {
 	if n > 0 {
 		return fx(n - 1)
 	}
-	(info["all_ids"])
+	info.all_ids
 }
 fx(3)
-== Eval  ==> {0:["E","PI","abs","fx","log2","printf"],1:["n","self"],2:["fx","n","self"],3:["fx","n","self"],4:["fx","n","self"]}
-$ info["gofuncs"]
-== Parse ==> (info["gofuncs"])
-== Eval  ==> ["acos","asin","atan","ceil","cos","exp","floor","ln","log10","pow","round","sin","sprintf","sqrt","tan","trunc"]
-$ info["keywords"]
-== Parse ==> (info["keywords"])
+== Eval  ==> {0:["E","PI","abs","fact","fx","log2","n","printf"],1:["n","self"],2:["fx","n","self"],3:["fx","n","self"],4:["fx","n","self"]}
+$ info["gofuncs"] // other way to access map keys, for when they aren't strings for instance
+== Parse ==> info["gofuncs"] // other way to access map keys, for when they aren't strings for instance
+== Eval  ==> ["acos","asin","atan","ceil","cos","eval","exp","floor","json","ln","log10","pow","round","sin","sprintf","sqrt","tan","trunc","unjson"]
+$ info.keywords
+== Parse ==> info.keywords
 == Eval  ==> ["else","error","false","first","func","if","len","log","macro","print","println","quote","rest","return","true","unquote"]
 ```
 
@@ -71,7 +71,7 @@ Functional int, float, string and boolean expressions
 
 Functions, lambdas, closures (including recursion in anonymous functions, using `self()`)
 
-Arrays, maps
+Arrays, maps (including map.key as map["key"] shorthand access)
 
 print, log
 

ast/ast.go

@@ -422,9 +422,11 @@ func (ie IndexExpression) PrettyPrint(out *PrintState) *PrintState {
 		out.Print("(")
 	}
 	ie.Left.PrettyPrint(out)
-	out.Print("[")
+	out.Print(ie.Literal())
 	ie.Index.PrettyPrint(out)
-	out.Print("]")
+	if ie.Token.Type() == token.LBRACKET {
+		out.Print("]")
+	}
 	if out.ExpressionLevel > 0 {
 		out.Print(")")
 	}

eval/eval.go

@@ -217,7 +217,13 @@ func (s *State) evalInternal(node any) object.Object { //nolint:funlen // quite
 		return s.evalMapLiteral(node)
 	case *ast.IndexExpression:
 		left := s.evalInternal(node.Left)
-		index := s.evalInternal(node.Index)
+		var index object.Object
+		if node.Token.Type() == token.DOT {
+			// index is the string value and not an identifier.
+			index = object.String{Value: node.Index.Value().Literal()}
+		} else {
+			index = s.evalInternal(node.Index)
+		}
 		return evalIndexExpression(left, index)
 	case *ast.Comment:
 		return object.NULL

eval/eval_test.go

@@ -137,6 +137,7 @@ func TestEvalBooleanExpression(t *testing.T) {
 		{"(1 > 2) == false", true},
 		{`"hello" == "world"`, false},
 		{`"hello" == "hello"`, true},
+		{`info["all_ids"] == info.all_ids`, true},
 	}
 
 	for _, tt := range tests {
@@ -611,14 +612,26 @@ func TestMapIndexExpressions(t *testing.T) {
 			`{"foo": 5}["foo"]`,
 			5,
 		},
+		{
+			`{"foo": 5}.foo`, // dot notation
+			5,
+		},
 		{
 			`{"foo": 5}["bar"]`,
 			nil,
 		},
+		{
+			`{"foo": 5}.bar`,
+			nil,
+		},
 		{
 			`key = "foo"; {"foo": 5}[key]`,
 			5,
 		},
+		{
+			`key = "foo"; {"foo": 5}.key`, // doesn't work (on puprpose), dot notation is string not eval.
+			nil,
+		},
 		{
 			`{}["foo"]`,
 			nil,

examples/namespaced_function.gr

@@ -0,0 +1,12 @@
+// A map is basically defining a namespace thanks to the DOT access syntax.
+n1 = {
+	"f1": func() {
+		println("f1")
+	},
+	"f2": func(x) {
+		x+1
+	},
+}
+
+n1.f1()
+n1.f2(41)

examples/sample.gr

@@ -28,7 +28,7 @@ m={"key": a, 73: 29} // so do maps
 println("m is:", m) // stdout print
 println("Outputting a smiley: 😀")
 
-first(m["key"]) // get the value from key from map, which is an array, and the first element of the array is our factorial 5
-// could also have been m["key"][0]
+first(m.key) // get the value from key from map, which is an array, and the first element of the array is our factorial 5
+// (dot notation .key is shorthand for ["key"]), could also have been first(m["key"]) or m["key"][0] or m.key[0]
 
 // ^^^ gorepl sample.gr should output 120

lexer/lexer.go

@@ -77,6 +77,9 @@ func (l *Lexer) NextToken() *token.Token {
 			l.pos++
 			return token.ConstantTokenChar2(ch, nextChar)
 		}
+		if !isDigit(nextChar) {
+			return token.ConstantTokenChar(ch) // DOT token
+		}
 		// number can start with . eg .5
 		return token.Intern(l.readNumber(ch))
 	default:

lexer/lexer_test.go

@@ -43,6 +43,7 @@ j--
 /* This is a
    multiline comment */
 ..
+a.b
 @
 `
 	tests := []struct {
@@ -163,6 +164,9 @@ j--
 		{token.BLOCKCOMMENT, "/*/*/"},
 		{token.BLOCKCOMMENT, "/* This is a\n   multiline comment */"},
 		{token.DOTDOT, ".."},
+		{token.IDENT, "a"},
+		{token.DOT, "."},
+		{token.IDENT, "b"},
 		{token.ILLEGAL, "@"},
 		{token.EOF, ""},
 	}
@@ -279,7 +283,7 @@ func TestReadFloatNumber(t *testing.T) {
 		{"1.23e-abc", "1.23"},
 		{"123..", "123."},
 		{"1..23", "1."},
-		{".e3", "."},
+		{".e3", "."}, // that's now the DOT and not a (bad) float.
 		{"100..", "100."},
 		{"1000_000.5", "1000_000.5"},
 		{"1000_000.5_6", "1000_000.5_6"},
@@ -293,6 +297,12 @@ func TestReadFloatNumber(t *testing.T) {
 		tok := l.NextToken()
 		tokT := tok.Type()
 		result := tok.Literal()
+		if tt.expected == "." {
+			if tokT != token.DOT {
+				t.Errorf("input: %q, expected a DOT, got: %#v", tt.input, tok.DebugString())
+			}
+			continue
+		}
 		isFloat := (tokT == token.FLOAT)
 		if !isFloat {
 			t.Errorf("input: %q, expected a float number, got: %#v", tt.input, tok.DebugString())

main_test.txtar

@@ -113,14 +113,20 @@ stdout '^3$'
 !stderr .
 
 # eval() runs in the same context as when called
-grol -quiet -c 'func foo(x) {eval("info")};foo(1)["all_ids"][1]'
-stdout '^\["self","x"]$'
+grol -quiet -c 'func foo(x) {eval("info")};foo(42)["all_ids"][1]'
+stdout '^{"self":func foo\(x\){eval\("info"\)},"x":42}$'
 !stderr .
 
 # json of (nested) arrays
 grol -quiet -c 'a=[1,2,3,["a", "b"],4];println(json(a))'
 stdout '^\[1,2,3,\["a","b"],4]$'
 !stderr .
+
+# dot notation and priority with functions
+grol -quiet -c 'n1={"f1":func(){println("f1")},"f2":func(x){x+1}}n1.f1()n1.f2(41)'
+stdout '^f1\n42$'
+!stderr .
+
 -- foo.inp --
 foo
 -- sample_test.gr --

object/state.go

@@ -69,22 +69,20 @@ func (e *Environment) BaseInfo() Map {
 }
 
 func (e *Environment) Info() Object {
-	allKeys := make(Map, e.depth)
+	allKeys := make([]Object, e.depth+1)
 	for {
-		keys := make([]Object, 0, e.Len())
-		for k := range e.store {
-			keys = append(keys, String{Value: k})
+		val := make(Map, e.Len())
+		for k, v := range e.store {
+			val[String{Value: k}] = v
 		}
-		arr := Array{Elements: keys}
-		sort.Sort(arr)
-		allKeys[Integer{Value: int64(e.depth)}] = arr
+		allKeys[e.depth] = val
 		if e.outer == nil {
 			break
 		}
 		e = e.outer
 	}
 	info := e.BaseInfo()
-	info[String{"all_ids"}] = allKeys
+	info[String{"all_ids"}] = Array{Elements: allKeys}
 	return info
 }