Add methods from List/Map to Listing/Mapping

pkl-core/src/main/java/org/pkl/core/stdlib/base/ListingNodes.java

@@ -15,9 +15,11 @@
  */
 package org.pkl.core.stdlib.base;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.LoopNode;
+import org.pkl.core.ast.PklNode;
 import org.pkl.core.ast.lambda.*;
 import org.pkl.core.ast.member.ObjectMember;
 import org.pkl.core.runtime.*;
@@ -44,6 +46,23 @@ protected boolean eval(VmListing self) {
     }
   }
 
+  public abstract static class lastIndex extends ExternalPropertyNode {
+    @Specialization
+    protected long eval(VmListing self) {
+      return self.getLength() - 1;
+    }
+  }
+
+  public abstract static class getOrNull extends ExternalMethod1Node {
+    @Specialization
+    protected Object eval(VmListing self, long index) {
+      if (index < 0 || index >= self.getLength()) {
+        return VmNull.withoutDefault();
+      }
+      return VmUtils.readMember(self, index);
+    }
+  }
+
   public abstract static class isDistinct extends ExternalPropertyNode {
     @Specialization
     @TruffleBoundary
@@ -89,6 +108,58 @@ protected VmListing eval(VmListing self) {
     }
   }
 
+  public abstract static class first extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      checkNonEmpty(self, this);
+      return VmUtils.readMember(self, 0L);
+    }
+  }
+
+  public abstract static class firstOrNull extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      if (self.isEmpty()) {
+        return VmNull.withoutDefault();
+      }
+      return VmUtils.readMember(self, 0L);
+    }
+  }
+
+  public abstract static class last extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      checkNonEmpty(self, this);
+      return VmUtils.readMember(self, self.getLength() - 1L);
+    }
+  }
+
+  public abstract static class lastOrNull extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      var length = self.getLength();
+      return length == 0 ? VmNull.withoutDefault() : VmUtils.readMember(self, length - 1L);
+    }
+  }
+
+  public abstract static class single extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      checkSingleton(self, this);
+      return VmUtils.readMember(self, 0L);
+    }
+  }
+
+  public abstract static class singleOrNull extends ExternalPropertyNode {
+    @Specialization
+    protected Object eval(VmListing self) {
+      if (self.getLength() != 1) {
+        return VmNull.withoutDefault();
+      }
+      return VmUtils.readMember(self, 0L);
+    }
+  }
+
   public abstract static class distinctBy extends ExternalMethod1Node {
     @Child private ApplyVmFunction1Node applyNode = ApplyVmFunction1Node.create();
 
@@ -116,6 +187,59 @@ protected VmListing eval(VmListing self, VmFunction selector) {
     }
   }
 
+  public abstract static class every extends ExternalMethod1Node {
+    @Child private ApplyVmFunction1Node applyNode = ApplyVmFunction1Node.create();
+
+    @Specialization
+    protected boolean eval(VmListing self, VmFunction predicate) {
+      var result = new MutableBoolean(true);
+      self.iterateMemberValues(
+          (key, member, value) -> {
+            if (value == null) {
+              value = VmUtils.readMember(self, key);
+            }
+            result.set(applyNode.executeBoolean(predicate, value));
+            return result.get();
+          });
+      return result.get();
+    }
+  }
+
+  public abstract static class any extends ExternalMethod1Node {
+    @Child private ApplyVmFunction1Node applyNode = ApplyVmFunction1Node.create();
+
+    @Specialization
+    protected boolean eval(VmListing self, VmFunction predicate) {
+      var result = new MutableBoolean(false);
+      self.iterateMemberValues(
+          (key, member, value) -> {
+            if (value == null) {
+              value = VmUtils.readMember(self, key);
+            }
+            result.set(applyNode.executeBoolean(predicate, value));
+            return !result.get();
+          });
+      return result.get();
+    }
+  }
+
+  public abstract static class contains extends ExternalMethod1Node {
+    @Specialization
+    protected boolean eval(VmListing self, Object element) {
+      var result = new MutableBoolean(false);
+      self.iterateMemberValues(
+          (key, member, value) -> {
+            if (value == null) {
+              value = VmUtils.readMember(self, key);
+            }
+            result.set(element.equals(value));
+            return !result.get();
+          });
+      LoopNode.reportLoopCount(this, self.getLength());
+      return result.get();
+    }
+  }
+
   public abstract static class fold extends ExternalMethod2Node {
     @Child private ApplyVmFunction2Node applyLambdaNode = ApplyVmFunction2NodeGen.create();
 
@@ -194,4 +318,24 @@ protected VmSet eval(VmListing self) {
       return builder.build();
     }
   }
+
+  private static void checkNonEmpty(VmListing self, PklNode node) {
+    if (self.isEmpty()) {
+      CompilerDirectives.transferToInterpreter();
+      throw new VmExceptionBuilder()
+          .evalError("expectedNonEmptyListing")
+          .withLocation(node)
+          .build();
+    }
+  }
+
+  private static void checkSingleton(VmListing self, PklNode node) {
+    if (self.getLength() != 1) {
+      CompilerDirectives.transferToInterpreter();
+      throw new VmExceptionBuilder()
+          .evalError("expectedSingleElementListing")
+          .withLocation(node)
+          .build();
+    }
+  }
 }

pkl-core/src/main/java/org/pkl/core/stdlib/base/MappingNodes.java

@@ -19,6 +19,8 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.IndirectCallNode;
 import java.util.HashSet;
+import org.pkl.core.ast.lambda.ApplyVmFunction2Node;
+import org.pkl.core.ast.lambda.ApplyVmFunction2NodeGen;
 import org.pkl.core.ast.lambda.ApplyVmFunction3Node;
 import org.pkl.core.ast.lambda.ApplyVmFunction3NodeGen;
 import org.pkl.core.runtime.*;
@@ -27,6 +29,7 @@
 import org.pkl.core.stdlib.ExternalMethod2Node;
 import org.pkl.core.stdlib.ExternalPropertyNode;
 import org.pkl.core.util.EconomicMaps;
+import org.pkl.core.util.MutableBoolean;
 import org.pkl.core.util.MutableLong;
 import org.pkl.core.util.MutableReference;
 
@@ -86,6 +89,22 @@ protected boolean eval(VmMapping self, Object key) {
     }
   }
 
+  public abstract static class containsValue extends ExternalMethod1Node {
+    @Specialization
+    protected boolean eval(VmMapping self, Object value) {
+      var foundValue = new MutableBoolean(false);
+      self.iterateMemberValues(
+          (key, member, memberValue) -> {
+            if (memberValue == null) {
+              memberValue = VmUtils.readMember(self, key);
+            }
+            foundValue.set(value.equals(memberValue));
+            return !foundValue.get();
+          });
+      return foundValue.get();
+    }
+  }
+
   public abstract static class getOrNull extends ExternalMethod1Node {
     @Child private IndirectCallNode callNode = IndirectCallNode.create();
 
@@ -110,6 +129,42 @@ protected Object eval(VmMapping self, Object initial, VmFunction function) {
     }
   }
 
+  public abstract static class every extends ExternalMethod1Node {
+    @Child private ApplyVmFunction2Node applyLambdaNode = ApplyVmFunction2NodeGen.create();
+
+    @Specialization
+    protected boolean eval(VmMapping self, VmFunction function) {
+      var result = new MutableBoolean(true);
+      self.iterateMemberValues(
+          (key, member, value) -> {
+            if (value == null) {
+              value = VmUtils.readMember(self, key);
+            }
+            result.set(applyLambdaNode.executeBoolean(function, key, value));
+            return result.get();
+          });
+      return result.get();
+    }
+  }
+
+  public abstract static class any extends ExternalMethod1Node {
+    @Child private ApplyVmFunction2Node applyLambdaNode = ApplyVmFunction2NodeGen.create();
+
+    @Specialization
+    protected boolean eval(VmMapping self, VmFunction function) {
+      var result = new MutableBoolean(false);
+      self.iterateMemberValues(
+          (key, member, value) -> {
+            if (value == null) {
+              value = VmUtils.readMember(self, key);
+            }
+            result.set(applyLambdaNode.executeBoolean(function, key, value));
+            return !result.get();
+          });
+      return result.get();
+    }
+  }
+
   public abstract static class toMap extends ExternalMethod0Node {
     @Specialization
     protected VmMap eval(VmMapping self) {

pkl-core/src/main/resources/org/pkl/core/errorMessages.properties

@@ -518,6 +518,12 @@ Expected a single-element collection.
 cannotFlattenCollectionWithNonCollectionElement=\
 Cannot flatten a collection containing a non-collection element.
 
+expectedNonEmptyListing=\
+Expected a non-empty Listing.
+
+expectedSingleElementListing=\
+Expected a single-element Listing.
+
 integerOverflow=\
 Integer overflow.
 

pkl-core/src/test/files/LanguageSnippetTests/input/api/listing.pkl

@@ -23,13 +23,25 @@ local duplicate: Listing<Person> = (base) {
   new { name = "Elf Owl" }
 }
 
+local altered: Listing<Person> = (base) {
+  [0] { name = "Wood Pigeon" }
+}
+
 facts {
   ["isEmpty"] {
     empty.isEmpty
     empty2.isEmpty
     !base.isEmpty
     !derived.isEmpty
   }
+
+  ["lastIndex"] {
+    empty.lastIndex == -1
+    empty2.lastIndex == -1
+    base.lastIndex == 2
+    derived.lastIndex == 4
+    duplicate.lastIndex == 5
+  }
 
   ["isDistinct"] {
     empty.isDistinct
@@ -58,6 +70,72 @@ facts {
     !derived.isDistinctBy((it) -> it.getClass())
     !duplicate.isDistinctBy((it) -> it.getClass())
   }
+
+  ["getOrNull"] {
+    empty.getOrNull(-1) == null
+    empty.getOrNull(0) == null
+    base.getOrNull(-1) == null
+    for (i, v in base) {
+      base.getOrNull(i) == v
+    }
+    base.getOrNull(base.length) == null
+  }
+
+  ["first"] {
+    module.catch(() -> empty.first) == "Expected a non-empty Listing."
+    base.first == base[0]
+    derived.first == base[0]
+  }
+
+  ["firstOrNull"] {
+    empty.firstOrNull == null
+    base.firstOrNull == base[0]
+    derived.firstOrNull == base[0]
+  }
+
+  ["last"] {
+    module.catch(() -> empty.last) == "Expected a non-empty Listing."
+    base.last == base[2]
+    derived.last == derived[4]
+  }
+
+  ["lastOrNull"] {
+    empty.lastOrNull == null
+    base.lastOrNull == base[2]
+    derived.lastOrNull == derived[4]
+  }
+
+  ["single"] {
+    module.catch(() -> empty.single) == "Expected a single-element Listing."
+    module.catch(() -> base.single) == "Expected a single-element Listing."
+    new Listing { 42 }.single == 42
+  }
+
+  ["singleOrNull"] {
+    empty.singleOrNull == null
+    base.singleOrNull == null
+    new Listing { 42 }.singleOrNull == 42
+  }
+
+  ["every"] {
+    !base.every((it) -> it.name.contains("rot"))
+    base.every((it) -> !it.name.isBlank)
+    !((base) { new { name = "EEEEE" } }).every((it) -> it.name.contains("rot"))
+  }
+
+  ["any"] {
+    base.any((it) -> it.name.contains("rot"))
+    !base.any((it) -> it.name.contains("inch"))
+    ((base) { new { name = "EEEEE" } }).any((it) -> it.name.contains("rot"))
+  }
+
+  ["contains"] {
+    !empty.contains(0)
+    base.contains(base[1])
+    derived.contains(base[1])
+    derived.contains(derived[3])
+    !altered.contains(base[0])
+  }
 }
 
 examples {