Add support for optional arrow syntax: (2 ← 1) = (1 → 2) = (1 2)

csharp/Platform.Protocols.Lino.Tests/SingleLineParserTests.cs

@@ -312,5 +312,51 @@ public static void TestValueLinkParserTest()
             Assert.Null(result[0].Id);
             Assert.Equal(3, result[0].Values?.Count);
         }
+
+        [Fact]
+        public static void TestRightArrowSyntaxTest()
+        {
+            var input = "(1 → 2)";
+            var parser = new Parser();
+            var links = parser.Parse(input);
+            var target = links.Format();
+            Assert.Equal("(1 2)", target);
+        }
+
+        [Fact]
+        public static void TestLeftArrowSyntaxTest()
+        {
+            var input = "(2 ← 1)";
+            var parser = new Parser();
+            var links = parser.Parse(input);
+            var target = links.Format();
+            Assert.Equal("(1 2)", target);
+        }
+
+        [Fact]
+        public static void TestArrowSyntaxEquivalenceTest()
+        {
+            var parser = new Parser();
+            var normal = parser.Parse("(1 2)");
+            var rightArrow = parser.Parse("(1 → 2)");
+            var leftArrow = parser.Parse("(2 ← 1)");
+
+            var normalFormatted = normal.Format();
+            var rightArrowFormatted = rightArrow.Format();
+            var leftArrowFormatted = leftArrow.Format();
+
+            Assert.Equal(normalFormatted, rightArrowFormatted);
+            Assert.Equal(normalFormatted, leftArrowFormatted);
+        }
+
+        [Fact]
+        public static void TestArrowSyntaxWithNamesTest()
+        {
+            var input = "(papa → mama)";
+            var parser = new Parser();
+            var links = parser.Parse(input);
+            var target = links.Format();
+            Assert.Equal("(papa mama)", target);
+        }
     }
 }

csharp/Platform.Protocols.Lino/Parser.peg

@@ -11,9 +11,9 @@ anyLink <Link<string>> = ml:multiLineAnyLink eol { ml } / sl:singleLineAnyLink {
 multiLineAnyLink <Link<string>> = multiLineValueLink / multiLineLink
 singleLineAnyLink <Link<string>> = fl:singleLineLink eol { fl } / vl:singleLineValueLink eol { vl }
 multiLineValueAndWhitespace <Link<string>> = value:referenceOrLink _ { value }
-multiLineValues <IList<Link<string>>> = _ list:multiLineValueAndWhitespace* { list }
+multiLineValues <IList<Link<string>>> = _ list:arrowValues { list } / _ list:multiLineValueAndWhitespace* { list }
 singleLineValueAndWhitespace <Link<string>> = __ value:referenceOrLink { value }
-singleLineValues <IList<Link<string>>> = list:singleLineValueAndWhitespace+ { list }
+singleLineValues <IList<Link<string>>> = arrowValues / list:singleLineValueAndWhitespace+ { list }
 singleLineLink <Link<string>> = __ id:(reference) __ ":" v:singleLineValues { new Link<string>(id, v) }
 multiLineLink <Link<string>> = "(" _ id:(reference) _ ":" v:multiLineValues _ ")" { new Link<string>(id, v) }
 singleLineValueLink <Link<string>> = v:singleLineValues { new Link<string>(v) }
@@ -32,3 +32,7 @@ __ = [ \t]*
 _ = whiteSpaceSymbol*
 whiteSpaceSymbol = [ \t\n\r]
 referenceSymbol = [^ \t\n\r(:)]
+
+arrowValues <IList<Link<string>>> = rightArrowValues / leftArrowValues
+rightArrowValues <IList<Link<string>>> = left:referenceOrLink _ "→" _ right:referenceOrLink { new List<Link<string>> { left, right } }
+leftArrowValues <IList<Link<string>>> = right:referenceOrLink _ "←" _ left:referenceOrLink { new List<Link<string>> { left, right } }

csharp/Platform.Protocols.Lino/Platform.Protocols.Lino.csproj

@@ -4,7 +4,7 @@
     <Description>LinksPlatform's Platform.Protocols.Lino Class Library</Description>
     <Copyright>Konstantin Diachenko</Copyright>
     <AssemblyTitle>Platform.Protocols.Lino</AssemblyTitle>
-    <VersionPrefix>0.6.0</VersionPrefix>
+    <VersionPrefix>0.7.0</VersionPrefix>
     <Authors>Konstantin Diachenko</Authors>
     <TargetFramework>net8</TargetFramework>
     <PackageId>Platform.Protocols.Lino</PackageId>
@@ -22,7 +22,9 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <LangVersion>latest</LangVersion>
-    <PackageReleaseNotes>Now empty list of links is supported.
+    <PackageReleaseNotes>Added support for optional arrow syntax: (2 ← 1) = (1 → 2) = (1 2).
+Arrow syntax provides intuitive directional notation for links.
+Now empty list of links is supported.
 (:) and : syntax for empty links is now forbidden, to reduce confusion.
 Singlet links are supported, no more point link terminology.</PackageReleaseNotes>
     <Nullable>enable</Nullable>

examples/arrow_syntax_test.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+
+import { Parser } from '../js/src/Parser.js';
+import { formatLinks } from '../js/src/Link.js';
+
+const parser = new Parser();
+
+console.log("Testing Arrow Syntax Implementation");
+console.log("===================================");
+
+// Test the examples from the issue
+const tests = [
+    "(2 ← 1)",
+    "(1 → 2)", 
+    "(1 2)",
+    "(papa → mama)",
+    "(daughter ← papa)"
+];
+
+console.log("Testing equivalence: (2 ← 1) = (1 → 2) = (1 2)");
+console.log("");
+
+for (const test of tests) {
+    try {
+        const result = parser.parse(test);
+        const formatted = formatLinks(result);
+        console.log(`Input:  ${test}`);
+        console.log(`Output: ${formatted}`);
+        console.log("");
+    } catch (error) {
+        console.log(`Error parsing "${test}": ${error.message}`);
+    }
+}
+
+console.log("All tests completed!");

js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linksplatform/protocols-lino",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Lino protocol parser for JavaScript",
   "main": "dist/index.js",
   "type": "module",

js/src/grammar.pegjs

@@ -45,11 +45,11 @@ singleLineAnyLink = fl:singleLineLink eol { return fl; }
 
 multiLineValueAndWhitespace = value:referenceOrLink _ { return value; }
 
-multiLineValues = _ list:multiLineValueAndWhitespace* { return list; }
+multiLineValues = _ list:arrowValues { return list; } / _ list:multiLineValueAndWhitespace* { return list; }
 
 singleLineValueAndWhitespace = __ value:referenceOrLink { return value; }
 
-singleLineValues = list:singleLineValueAndWhitespace+ { return list; }
+singleLineValues = arrowValues / list:singleLineValueAndWhitespace+ { return list; }
 
 singleLineLink = __ id:reference __ ":" v:singleLineValues { return { id: id, values: v }; }
 
@@ -81,4 +81,10 @@ _ = whiteSpaceSymbol*
 
 whiteSpaceSymbol = [ \t\n\r]
 
-referenceSymbol = [^ \t\n\r(:)]
+referenceSymbol = [^ \t\n\r(:)]
+
+arrowValues = rightArrowValues / leftArrowValues
+
+rightArrowValues = left:referenceOrLink _ "→" _ right:referenceOrLink { return [left, right]; }
+
+leftArrowValues = right:referenceOrLink _ "←" _ left:referenceOrLink { return [left, right]; }