feat: add generic positional element access

README.md

@@ -57,6 +57,25 @@ This separation allows the same parser to support:
 * language servers
 * syntax highlighting and other editor tooling
 
+### Structural access
+
+Expressif distinguishes record fields from elements of ordered values:
+
+```text
+.name       named field of the current record
+.0          positional field of the current record
+$0          first element of the current tuple or array
+$1          second element of the current tuple or array
+$^0         last element of the current tuple or array
+$^1         second-to-last element of the current tuple or array
+```
+
+Element positions are zero-based. `$n` counts from the beginning and `$^n`
+counts from the end. The parser represents both tuple and array access with the
+same `positional_element_access` node; downstream binders decide whether the
+runtime value supports positional access and how invalid or out-of-range access
+is handled.
+
 ## Repository structure
 
 ```text

bindings/csharp/Expressif.Syntax.Tests/SyntaxBindingTests.cs

@@ -79,6 +79,38 @@ public void TemporalFormsRemainDistinct(string source, Type expected)
         Assert.That(root.Value, Is.TypeOf(expected).With.Property(nameof(SyntaxNode.Text)).EqualTo(source));
     }
 
+    [TestCase("$0", 0, false)]
+    [TestCase("$1", 1, false)]
+    [TestCase("$^0", 0, true)]
+    [TestCase("$^1", 1, true)]
+    public void PositionalElementAccessExposesDirectionAndIndex(string source, int index, bool fromEnd)
+    {
+        var root = (ClosedExpressionSyntax)ExpressifSyntax.Parse(source);
+        var access = (PositionalElementAccessSyntax)root.Value;
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(access.Index, Is.EqualTo(index));
+            Assert.That(access.FromEnd, Is.EqualTo(fromEnd));
+            Assert.That(access.Text, Is.EqualTo(source));
+        });
+    }
+
+    [Test]
+    public void PositionalElementAccessCanBeAnArgumentAndPipelineSource()
+    {
+        var argumentRoot = (OpenExpressionSyntax)ExpressifSyntax.Parse("select($1)");
+        var pipelineRoot = (ClosedExpressionSyntax)ExpressifSyntax.Parse("$^0 | upper");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(argumentRoot.Pipeline.Single().Arguments.Single().Value,
+                Is.TypeOf<PositionalElementAccessSyntax>());
+            Assert.That(pipelineRoot.Value, Is.TypeOf<PositionalElementAccessSyntax>());
+            Assert.That(pipelineRoot.Pipeline.Single().Name, Is.EqualTo("upper"));
+        });
+    }
+
     [Test]
     public void SourceTextAndRangesAreLossless()
     {

bindings/csharp/Expressif.Syntax/ExpressifSyntax.cs

@@ -77,6 +77,7 @@ private static PositionalArgumentSyntax BindArgument(TsNode node)
 
     private static ValueSyntax BindValue(TsNode node) => node.Type switch
     {
+        "positional_element_access" => new PositionalElementAccessSyntax(Span(node), node.Text),
         "numeric_literal" => new NumericLiteralSyntax(Span(node), node.Text),
         "boolean_literal" => new BooleanLiteralSyntax(Span(node), node.Text),
         "double_quoted_literal" => new QuotedLiteralSyntax(Span(node), node.Text, QuotingStyle.DoubleQuote),

bindings/csharp/Expressif.Syntax/SyntaxNodes.cs

@@ -14,6 +14,7 @@ public enum SyntaxKind
     DateLiteral,
     DateTimeLiteral,
     TimeLiteral,
+    PositionalElementAccess,
 }
 
 public readonly record struct SourceSpan(int Start, int Length)
@@ -108,6 +109,19 @@ protected ValueSyntax(SyntaxKind kind, SourceSpan span, string text)
         : base(kind, span, text) { }
 }
 
+public sealed class PositionalElementAccessSyntax : ValueSyntax
+{
+    internal PositionalElementAccessSyntax(SourceSpan span, string text)
+        : base(SyntaxKind.PositionalElementAccess, span, text)
+    {
+        FromEnd = text[1] == '^';
+        Index = int.Parse(text.AsSpan(FromEnd ? 2 : 1), System.Globalization.CultureInfo.InvariantCulture);
+    }
+
+    public int Index { get; }
+    public bool FromEnd { get; }
+}
+
 public sealed class NumericLiteralSyntax : ValueSyntax
 {
     internal NumericLiteralSyntax(SourceSpan span, string text) : base(SyntaxKind.NumericLiteral, span, text) { }

grammar.js

@@ -54,6 +54,7 @@ export default grammar({
       $.variable,
       $.property_reference,
       $.index_reference,
+      $.positional_element_access,
       $.numeric_literal,
       $.boolean_literal,
       $.quoted_literal,
@@ -111,6 +112,8 @@ export default grammar({
 
     index_reference: (_) => /\[(?:0|[1-9][0-9]*)\]/,
 
+    positional_element_access: (_) => /\$\^?(?:0|[1-9][0-9]*)/,
+
     boolean_literal: (_) => choice("#true", "#false"),
 
     quoted_literal: ($) => choice(