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
 }
 

parser/parser.go

@@ -24,6 +24,7 @@ const (
 	PREFIX      // -X or !X
 	CALL        // myFunction(X)
 	INDEX       // array[index]
+	DOTINDEX    // map.str access
 )
 
 //go:generate stringer -type=Priority
@@ -117,6 +118,7 @@ func New(l *lexer.Lexer) *Parser {
 	p.registerInfix(token.GTEQ, p.parseInfixExpression)
 	p.registerInfix(token.LPAREN, p.parseCallExpression)
 	p.registerInfix(token.LBRACKET, p.parseIndexExpression)
+	p.registerInfix(token.DOT, p.parseIndexExpression)
 	// no let:
 	p.registerInfix(token.ASSIGN, p.parseInfixExpression)
 
@@ -269,6 +271,11 @@ func (p *Parser) noPrefixParseFnError(t token.Type) {
 
 func (p *Parser) parseExpression(precedence Priority) ast.Node {
 	log.Debugf("parseExpression: %s precedence %s", p.curToken.DebugString(), precedence)
+	if p.curToken.Type() == token.EOL {
+		log.Debugf("parseExpression: EOL")
+		p.continuationNeeded = true
+		return nil
+	}
 	prefix := p.prefixParseFns[p.curToken.Type()]
 	if prefix == nil {
 		p.noPrefixParseFnError(p.curToken.Type())
@@ -387,6 +394,7 @@ var precedences = map[token.Type]Priority{
 	token.PERCENT:  PRODUCT,
 	token.LPAREN:   CALL,
 	token.LBRACKET: INDEX,
+	token.DOT:      DOTINDEX,
 }
 
 func (p *Parser) peekPrecedence() Priority {
@@ -574,9 +582,17 @@ func (p *Parser) parseExpressionList(end token.Type) []ast.Node {
 func (p *Parser) parseIndexExpression(left ast.Node) ast.Node {
 	exp := &ast.IndexExpression{Left: left}
 	exp.Token = p.curToken
+	isDot := p.curToken.Type() == token.DOT
 
 	p.nextToken()
-	exp.Index = p.parseExpression(LOWEST)
+	prec := LOWEST
+	if isDot {
+		prec = DOTINDEX
+	}
+	exp.Index = p.parseExpression(prec)
+	if isDot {
+		return exp
+	}
 
 	if !p.expectPeek(token.RBRACKET) {
 		return nil
@@ -592,6 +608,9 @@ func (p *Parser) parseMapLiteral() ast.Node {
 
 	for !p.peekTokenIs(token.RBRACE) {
 		p.nextToken()
+		if p.continuationNeeded {
+			return nil
+		}
 		key := p.parseExpression(LOWEST)
 
 		if !p.expectPeek(token.COLON) {

parser/priority_string.go

@@ -90,6 +90,7 @@ const (
 	LBRACKET
 	RBRACKET
 	COLON
+	DOT
 
 	endSingleCharTokens
 
@@ -220,6 +221,7 @@ func Init() {
 	assoc(LBRACKET, '[')
 	assoc(RBRACKET, ']')
 	assoc(COLON, ':')
+	assoc(DOT, '.')
 	// Verify we have all of them.
 	for i := startSingleCharTokens + 1; i < endSingleCharTokens; i++ {
 		b, ok := tToChar[i]