refactor(store): simplify return types

Prefers sealed non-generic interfaces over wildcard types to avoid
confusion about method return types, especially in collections
(see SonarQube rule java:S1452).

27 files changed, 337 insertions, 262 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java b/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java
new file mode 100644
index 00000000..b94b9f38
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java
@@ -0,0 +1,5 @@
+package tools.refinery.store.map;
+
+public sealed interface AnyVersionedMap extends Versioned permits VersionedMap {
+        long getSize();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Cursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/Cursor.java
index 9c465ddc..b420585c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/Cursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Cursor.java
@@ -1,14 +1,21 @@
 package tools.refinery.store.map;
 
-import java.util.List;
-
-public interface Cursor<K,V> {
-        public K getKey();
-        public V getValue();
-        public boolean isTerminated();
-        public boolean move();
-        public boolean isDirty();
-        
-        @SuppressWarnings("squid:S1452")
-        public List<VersionedMap<?,?>> getDependingMaps();
+import java.util.Set;
+
+public interface Cursor<K, V> {
+        K getKey();
+
+        V getValue();
+
+        boolean isTerminated();
+
+        boolean move();
+
+        default boolean isDirty() {
+                return false;
+        }
+
+        default Set<AnyVersionedMap> getDependingMaps() {
+                return Set.of();
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
index a8a64d08..31985e94 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
@@ -1,13 +1,13 @@
 package tools.refinery.store.map;
 
-public interface VersionedMap<K,V> extends Versioned{
-        public V get(K key);
-        public Cursor<K,V> getAll();
-        
-        public V put(K key, V value);
-        public void putAll(Cursor<K,V> cursor);
-        
-        public long getSize();
-        
-        public DiffCursor<K,V> getDiffCursor(long state);
+public non-sealed interface VersionedMap<K, V> extends AnyVersionedMap {
+        V get(K key);
+
+        Cursor<K, V> getAll();
+
+        V put(K key, V value);
+
+        void putAll(Cursor<K, V> cursor);
+
+        DiffCursor<K, V> getDiffCursor(long state);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java
index 723e5ec4..3856460d 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java
@@ -1,14 +1,14 @@
 package tools.refinery.store.map;
 
 public class VersionedMapStoreConfiguration {
-        
+
         public VersionedMapStoreConfiguration() {
-                
+
         }
-        public VersionedMapStoreConfiguration(boolean immutableWhenCommiting, boolean sharedNodeCacheInStore,
+        public VersionedMapStoreConfiguration(boolean immutableWhenCommitting, boolean sharedNodeCacheInStore,
                         boolean sharedNodeCacheInStoreGroups) {
                 super();
-                this.immutableWhenCommiting = immutableWhenCommiting;
+                this.immutableWhenCommitting = immutableWhenCommitting;
                 this.sharedNodeCacheInStore = sharedNodeCacheInStore;
                 this.sharedNodeCacheInStoreGroups = sharedNodeCacheInStoreGroups;
         }
@@ -18,13 +18,13 @@ public class VersionedMapStoreConfiguration {
          * by releasing immutable nodes, but it may decrease performance by recreating
          * immutable nodes upon changes (some evidence).
          */
-        private boolean immutableWhenCommiting = true;
-        public boolean isImmutableWhenCommiting() {
-                return immutableWhenCommiting;
+        private boolean immutableWhenCommitting = true;
+        public boolean isImmutableWhenCommitting() {
+                return immutableWhenCommitting;
         }
 
         /**
-         * If true, all subnodes are cached within a {@link VersionedMapStore}. It
+         * If true, all sub-nodes are cached within a {@link VersionedMapStore}. It
          * decreases the memory requirements. It may increase performance by discovering
          * existing immutable copy of a node (some evidence). Additional overhead may
          * decrease performance (no example found). The option permits the efficient
@@ -34,9 +34,9 @@ public class VersionedMapStoreConfiguration {
         public boolean isSharedNodeCacheInStore() {
                 return sharedNodeCacheInStore;
         }
-        
+
         /**
-         * If true, all subnodes are cached within a group of
+         * If true, all sub-nodes are cached within a group of
          * {@link VersionedMapStoreImpl#createSharedVersionedMapStores(int, ContinousHashProvider, Object, VersionedMapStoreConfiguration)}.
          * If {@link VersionedMapStoreConfiguration#sharedNodeCacheInStore} is
          * <code>false</code>, then it has currently no impact.
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java
index a626a5e8..113874e7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java
@@ -1,22 +1,15 @@
 package tools.refinery.store.map;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
 import tools.refinery.store.map.internal.ImmutableNode;
 import tools.refinery.store.map.internal.MapDiffCursor;
 import tools.refinery.store.map.internal.Node;
 import tools.refinery.store.map.internal.VersionedMapImpl;
 
+import java.util.*;
+
 public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
         // Configuration
-        private final boolean immutableWhenCommiting;
+        private final boolean immutableWhenCommitting;
 
         // Static data
         protected final ContinousHashProvider<K> hashProvider;
@@ -29,7 +22,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
 
         public VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
                         VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommiting = config.isImmutableWhenCommiting();
+                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 if (config.isSharedNodeCacheInStore()) {
@@ -41,7 +34,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
 
         private VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
                         Map<Node<K, V>, ImmutableNode<K, V>> nodeCache, VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommiting = config.isImmutableWhenCommiting();
+                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 this.nodeCache = nodeCache;
@@ -77,7 +70,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
                         ContinousHashProvider<K> hashProvider, V defaultValue) {
                 return createSharedVersionedMapStores(amount, hashProvider, defaultValue, new VersionedMapStoreConfiguration());
         }
-        
+
         @Override
         public synchronized Set<Long> getStates() {
                 return new HashSet<>(states.keySet());
@@ -93,7 +86,6 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
                 ImmutableNode<K, V> data = revert(state);
                 return new VersionedMapImpl<>(this, hashProvider, defaultValue, data);
         }
-        
 
         public synchronized ImmutableNode<K, V> revert(long state) {
                 if (states.containsKey(state)) {
@@ -118,7 +110,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
                         throw new IllegalStateException("Map store run out of Id-s");
                 long id = nextID++;
                 this.states.put(id, immutable);
-                if (this.immutableWhenCommiting) {
+                if (this.immutableWhenCommitting) {
                         mapToUpdateRoot.setRoot(immutable);
                 }
                 return id;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java
index b90f5b71..1698830f 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java
@@ -1,128 +1,136 @@
 package tools.refinery.store.map.internal;
 
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+
 import java.util.ArrayDeque;
 import java.util.ConcurrentModificationException;
 import java.util.Iterator;
-import java.util.List;
-
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.map.VersionedMap;
+import java.util.Set;
 
-public class MapCursor<K,V> implements Cursor<K,V> {
+public class MapCursor<K, V> implements Cursor<K, V> {
         // Constants
         static final int INDEX_START = -1;
         static final int INDEX_FINISH = -2;
-        
+
         // Tree stack
-        ArrayDeque<Node<K,V>> nodeStack;
+        ArrayDeque<Node<K, V>> nodeStack;
         ArrayDeque<Integer> nodeIndexStack;
         int dataIndex;
-        
+
         // Values
         K key;
         V value;
-        
+
         // Hash code for checking concurrent modifications
-        final VersionedMap<K,V> map;
-        final int creationHash; 
-        
-        public MapCursor(Node<K, V> root, VersionedMap<K,V> map) {
+        final VersionedMap<K, V> map;
+        final int creationHash;
+
+        public MapCursor(Node<K, V> root, VersionedMap<K, V> map) {
                 // Initializing tree stack
                 super();
                 this.nodeStack = new ArrayDeque<>();
                 this.nodeIndexStack = new ArrayDeque<>();
-                if(root != null) {
+                if (root != null) {
                         this.nodeStack.add(root);
                         this.nodeIndexStack.push(INDEX_START);
                 }
-                
+
                 this.dataIndex = INDEX_START;
-                
+
                 // Initializing cache
                 this.key = null;
                 this.value = null;
-                
+
                 // Initializing state
-                this.map=map;
+                this.map = map;
                 this.creationHash = map.hashCode();
         }
-        
+
         public K getKey() {
                 return key;
         }
-        
+
         public V getValue() {
                 return value;
         }
-        
+
         public boolean isTerminated() {
                 return this.nodeStack.isEmpty();
         }
-        
+
         public boolean move() {
-                if(isDirty()) {
+                if (isDirty()) {
                         throw new ConcurrentModificationException();
                 }
-                if(!isTerminated()) {
-                        boolean result = this.nodeStack.peek().moveToNext(this);
-                        if(this.nodeIndexStack.size() != this.nodeStack.size()) {
+                if (!isTerminated()) {
+                        var node = this.nodeStack.peek();
+                        if (node == null) {
+                                throw new IllegalStateException("Cursor is not terminated but the current node is missing");
+                        }
+                        boolean result = node.moveToNext(this);
+                        if (this.nodeIndexStack.size() != this.nodeStack.size()) {
                                 throw new IllegalArgumentException("Node stack is corrupted by illegal moves!");
                         }
                         return result;
                 }
                 return false;
         }
+
         public boolean skipCurrentNode() {
                 nodeStack.pop();
                 nodeIndexStack.pop();
                 dataIndex = INDEX_FINISH;
                 return move();
         }
+
         @Override
         public boolean isDirty() {
                 return this.map.hashCode() != this.creationHash;
         }
+
         @Override
-        public List<VersionedMap<?, ?>> getDependingMaps() {
-                return List.of(this.map);
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Set.of(this.map);
         }
-        
-        public static <K,V> boolean sameSubnode(MapCursor<K,V> cursor1, MapCursor<K,V> cursor2) {
+
+        public static <K, V> boolean sameSubnode(MapCursor<K, V> cursor1, MapCursor<K, V> cursor2) {
                 Node<K, V> nodeOfCursor1 = cursor1.nodeStack.peek();
                 Node<K, V> nodeOfCursor2 = cursor2.nodeStack.peek();
-                if(nodeOfCursor1 != null && nodeOfCursor2 != null) {
+                if (nodeOfCursor1 != null && nodeOfCursor2 != null) {
                         return nodeOfCursor1.equals(nodeOfCursor2);
                 } else {
                         return false;
                 }
         }
-        
+
         /**
-         * 
          * @param <K>
          * @param <V>
          * @param cursor1
          * @param cursor2
-         * @return Positive number if cursor 1 is behind, negative number if cursor 2 is behind, and 0 if they are at the same position.
+         * @return Positive number if cursor 1 is behind, negative number if cursor 2 is behind, and 0 if they are at the
+         * same position.
          */
-        public static <K,V> int compare(MapCursor<K,V> cursor1, MapCursor<K,V> cursor2) {
+        public static <K, V> int compare(MapCursor<K, V> cursor1, MapCursor<K, V> cursor2) {
                 // two cursors are equally deep
                 Iterator<Integer> stack1 = cursor1.nodeIndexStack.descendingIterator();
                 Iterator<Integer> stack2 = cursor2.nodeIndexStack.descendingIterator();
-                if(stack1.hasNext()) {
-                        if(!stack2.hasNext()) {
+                if (stack1.hasNext()) {
+                        if (!stack2.hasNext()) {
                                 // stack 2 has no more element, thus stack 1 is deeper
                                 return 1;
                         }
                         int val1 = stack1.next();
                         int val2 = stack2.next();
-                        if(val1 < val2) {
+                        if (val1 < val2) {
                                 return -1;
-                        } else if(val2 < val1) {
+                        } else if (val2 < val1) {
                                 return 1;
                         }
                 }
-                if(stack2.hasNext()) {
+                if (stack2.hasNext()) {
                         // stack 2 has more element, thus stack 2 is deeper
                         return 1;
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
index a4ca813c..9cd78113 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
@@ -1,12 +1,13 @@
 package tools.refinery.store.map.internal;
 
-import java.util.List;
-import java.util.stream.Stream;
-
+import tools.refinery.store.map.AnyVersionedMap;
 import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMap;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * A cursor representing the difference between two states of a map.
@@ -18,10 +19,10 @@ public class MapDiffCursor<K, V> implements DiffCursor<K, V>, Cursor<K, V> {
         /**
          * Default nodeId representing missing elements.
          */
-        private V defaultValue;
-        private MapCursor<K, V> cursor1;
-        private MapCursor<K, V> cursor2;
-        private ContinousHashProvider<? super K> hashProvider;
+        private final V defaultValue;
+        private final MapCursor<K, V> cursor1;
+        private final MapCursor<K, V> cursor2;
+        private final ContinousHashProvider<? super K> hashProvider;
 
         // Values
         private K key;
@@ -75,8 +76,10 @@ public class MapDiffCursor<K, V> implements DiffCursor<K, V>, Cursor<K, V> {
         }
 
         @Override
-        public List<VersionedMap<?, ?>> getDependingMaps() {
-                return Stream.concat(cursor1.getDependingMaps().stream(), cursor2.getDependingMaps().stream()).toList();
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Stream.concat(cursor1.getDependingMaps().stream(), cursor2.getDependingMaps().stream())
+                                .map(AnyVersionedMap.class::cast)
+                                .collect(Collectors.toUnmodifiableSet());
         }
 
         protected void updateState() {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java
index 346fe596..866e7b33 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java
@@ -1,61 +1,59 @@
 package tools.refinery.store.map.internal;
 
+import tools.refinery.store.map.*;
+
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-
 /**
  * Not threadSafe in itself
- * @author Oszkar Semerath
  *
  * @param <K>
  * @param <V>
+ * @author Oszkar Semerath
  */
-public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
-        protected final VersionedMapStoreImpl<K,V> store;
-        
+public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
+        protected final VersionedMapStoreImpl<K, V> store;
+
         protected final ContinousHashProvider<K> hashProvider;
+
         protected final V defaultValue;
-        protected Node<K,V> root;
-        
-        private OldValueBox<V> oldValueBox = new OldValueBox<>();
-        
+        protected Node<K, V> root;
+
+        private final OldValueBox<V> oldValueBox = new OldValueBox<>();
+
         public VersionedMapImpl(
-                        VersionedMapStoreImpl<K,V> store,
+                        VersionedMapStoreImpl<K, V> store,
                         ContinousHashProvider<K> hashProvider,
-                        V defaultValue)
-        {
+                        V defaultValue) {
                 this.store = store;
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 this.root = null;
         }
+
         public VersionedMapImpl(
-                        VersionedMapStoreImpl<K,V> store,
+                        VersionedMapStoreImpl<K, V> store,
                         ContinousHashProvider<K> hashProvider,
-                        V defaultValue, Node<K,V> data)
-        {
+                        V defaultValue, Node<K, V> data) {
                 this.store = store;
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 this.root = data;
         }
-                
+
         public V getDefaultValue() {
                 return defaultValue;
         }
+
         public ContinousHashProvider<K> getHashProvider() {
                 return hashProvider;
         }
+
         @Override
         public V put(K key, V value) {
-                if(root!=null) {
+                if (root != null) {
                         root = root.putValue(key, value, oldValueBox, hashProvider, defaultValue, hashProvider.getHash(key, 0), 0);
                         return oldValueBox.getOldValue();
                 } else {
@@ -63,39 +61,40 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
                         return defaultValue;
                 }
         }
-        
+
         @Override
         public void putAll(Cursor<K, V> cursor) {
-                if(cursor.getDependingMaps().contains(this)) {
+                if (cursor.getDependingMaps().contains(this)) {
                         List<K> keys = new LinkedList<>();
                         List<V> values = new LinkedList<>();
-                        while(cursor.move()) {
+                        while (cursor.move()) {
                                 keys.add(cursor.getKey());
                                 values.add(cursor.getValue());
                         }
                         Iterator<K> keyIterator = keys.iterator();
                         Iterator<V> valueIterator = values.iterator();
-                        while(keyIterator.hasNext()) {
+                        while (keyIterator.hasNext()) {
                                 this.put(keyIterator.next(), valueIterator.next());
                         }
                 } else {
-                        while(cursor.move()) {
+                        while (cursor.move()) {
                                 this.put(cursor.getKey(), cursor.getValue());
                         }
                 }
         }
-        
+
         @Override
         public V get(K key) {
-                if(root!=null) {
+                if (root != null) {
                         return root.getValue(key, hashProvider, defaultValue, hashProvider.getHash(key, 0), 0);
                 } else {
                         return defaultValue;
                 }
         }
+
         @Override
         public long getSize() {
-                if(root == null) {
+                if (root == null) {
                         return 0;
                 } else {
                         return root.getSize();
@@ -104,22 +103,24 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
 
         @Override
         public Cursor<K, V> getAll() {
-                return new MapCursor<>(this.root,this);
+                return new MapCursor<>(this.root, this);
         }
+
         @Override
         public DiffCursor<K, V> getDiffCursor(long toVersion) {
                 Cursor<K, V> fromCursor = this.getAll();
                 VersionedMap<K, V> toMap = this.store.createMap(toVersion);
                 Cursor<K, V> toCursor = toMap.getAll();
-                return new MapDiffCursor<>(this.hashProvider,this.defaultValue, fromCursor, toCursor);
-                
+                return new MapDiffCursor<>(this.hashProvider, this.defaultValue, fromCursor, toCursor);
+
         }
-        
+
 
         @Override
         public long commit() {
-                return this.store.commit(root,this);
+                return this.store.commit(root, this);
         }
+
         public void setRoot(Node<K, V> root) {
                 this.root = root;
         }
@@ -128,44 +129,20 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
         public void restore(long state) {
                 root = this.store.revert(state);
         }
-        
-        @Override
-        public int hashCode() {
-                final int prime = 31;
-                int result = 1;
-                result = prime * result + ((root == null) ? 0 : root.hashCode());
-                return result;
-        }
-        
-        @Override
-        public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (obj == null)
-                        return false;
-                if (getClass() != obj.getClass())
-                        return false;
-                VersionedMapImpl<?,?> other = (VersionedMapImpl<?,?>) obj;
-                if (root == null) {
-                        if (other.root != null)
-                                return false;
-                } else if (!root.equals(other.root))
-                        return false;
-                return true;
-        }
+
         public void prettyPrint() {
                 StringBuilder s = new StringBuilder();
-                if(this.root != null) {
+                if (this.root != null) {
                         this.root.prettyPrint(s, 0, -1);
                         System.out.println(s.toString());
                 } else {
                         System.out.println("empty tree");
                 }
         }
+
         public void checkIntegrity() {
-                if(this.root != null) {
+                if (this.root != null) {
                         this.root.checkIntegrity(hashProvider, defaultValue, 0);
                 }
         }
-
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index a42d711a..69f57389 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -1,20 +1,24 @@
 package tools.refinery.store.model;
 
-import java.util.Set;
-
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.Versioned;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
 import tools.refinery.store.model.representation.DataRepresentation;
 
-public interface Model extends Versioned{
-        @SuppressWarnings("squid:S1452")
-        Set<DataRepresentation<?, ?>> getDataRepresentations();
-        
-        <K,V> V get(DataRepresentation<K,V> representation, K key);
-        <K,V> Cursor<K,V> getAll(DataRepresentation<K,V> representation);
-        <K,V> V put(DataRepresentation<K,V> representation, K key, V value);
-        <K,V> void putAll(DataRepresentation<K,V> representation, Cursor<K,V> cursor);
-        <K,V> long getSize(DataRepresentation<K,V> representation);
-        
+import java.util.Set;
+
+public interface Model extends Versioned {
+        Set<AnyDataRepresentation> getDataRepresentations();
+
+        <K, V> V get(DataRepresentation<K, V> representation, K key);
+
+        <K, V> Cursor<K, V> getAll(DataRepresentation<K, V> representation);
+
+        <K, V> V put(DataRepresentation<K, V> representation, K key, V value);
+
+        <K, V> void putAll(DataRepresentation<K, V> representation, Cursor<K, V> cursor);
+
+        long getSize(AnyDataRepresentation representation);
+
         ModelDiffCursor getDiffCursor(long to);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
index 91990fa6..d5bb541b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
@@ -1,26 +1,27 @@
 package tools.refinery.store.model;
 
-import java.util.Map;
-
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
 import tools.refinery.store.model.representation.DataRepresentation;
 
+import java.util.Map;
+
 public class ModelDiffCursor {
-        final Map<DataRepresentation<?, ?>,DiffCursor<?,?>> diffcursors;
+        final Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors;
 
-        public ModelDiffCursor(Map<DataRepresentation<?, ?>, DiffCursor<?, ?>> diffcursors) {
+        public ModelDiffCursor(Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors) {
                 super();
-                this.diffcursors = diffcursors;
+                this.diffCursors = diffCursors;
         }
-        
+
         @SuppressWarnings("unchecked")
-        public <K,V> DiffCursor<K,V> getCursor(DataRepresentation<K, V> representation) {
-                Cursor<?, ?> cursor = diffcursors.get(representation);
-                if(cursor != null) {
+        public <K, V> DiffCursor<K, V> getCursor(DataRepresentation<K, V> representation) {
+                Cursor<?, ?> cursor = diffCursors.get(representation);
+                if (cursor != null) {
                         return (DiffCursor<K, V>) cursor;
                 } else {
-                        throw new IllegalArgumentException("ModelCursor does not contain cursor for representation "+representation);
+                        throw new IllegalArgumentException("ModelCursor does not contain cursor for representation " + representation);
                 }
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index 682a0e78..84b67765 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -1,16 +1,17 @@
 package tools.refinery.store.model;
 
-import java.util.Set;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
 
-import tools.refinery.store.model.representation.DataRepresentation;
+import java.util.Set;
 
 public interface ModelStore {
-        @SuppressWarnings("squid:S1452")
-        Set<DataRepresentation<?, ?>> getDataRepresentations();
-        
+        Set<AnyDataRepresentation> getDataRepresentations();
+
         Model createModel();
+
         Model createModel(long state);
-        
+
         Set<Long> getStates();
+
         ModelDiffCursor getDiffCursor(long from, long to);
-}
\ No newline at end of file
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java
index d08cf0f8..2f73a0e5 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java
@@ -3,6 +3,7 @@ package tools.refinery.store.model;
 import tools.refinery.store.map.*;
 import tools.refinery.store.model.internal.ModelImpl;
 import tools.refinery.store.model.internal.SimilarRelationEquivalenceClass;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
 import tools.refinery.store.model.representation.AuxiliaryData;
 import tools.refinery.store.model.representation.DataRepresentation;
 import tools.refinery.store.model.representation.Relation;
@@ -13,26 +14,26 @@ import java.util.Map.Entry;
 
 public class ModelStoreImpl implements ModelStore {
 
-        private final Map<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> stores;
+        private final Map<AnyDataRepresentation, VersionedMapStore<?, ?>> stores;
 
-        public ModelStoreImpl(Set<DataRepresentation<?, ?>> dataRepresentations) {
+        public ModelStoreImpl(Set<AnyDataRepresentation> dataRepresentations) {
                 stores = initStores(dataRepresentations);
         }
 
-        private Map<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> initStores(
-                        Set<DataRepresentation<?, ?>> dataRepresentations) {
-                Map<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> result = new HashMap<>();
+        private Map<AnyDataRepresentation, VersionedMapStore<?, ?>> initStores(
+                        Set<AnyDataRepresentation> dataRepresentations) {
+                Map<AnyDataRepresentation, VersionedMapStore<?, ?>> result = new HashMap<>();
 
                 Map<SimilarRelationEquivalenceClass, List<Relation<?>>> symbolRepresentationsPerHashPerArity = new HashMap<>();
 
-                for (DataRepresentation<?, ?> dataRepresentation : dataRepresentations) {
+                for (AnyDataRepresentation dataRepresentation : dataRepresentations) {
                         if (dataRepresentation instanceof Relation<?> symbolRepresentation) {
                                 addOrCreate(symbolRepresentationsPerHashPerArity,
                                                 new SimilarRelationEquivalenceClass(symbolRepresentation), symbolRepresentation);
-                        } else if (dataRepresentation instanceof AuxiliaryData<?, ?>) {
-                                VersionedMapStoreImpl<?, ?> store = new VersionedMapStoreImpl<>(dataRepresentation.getHashProvider(),
-                                                dataRepresentation.getDefaultValue());
-                                result.put(dataRepresentation, store);
+                        } else if (dataRepresentation instanceof AuxiliaryData<?, ?> auxiliaryData) {
+                                VersionedMapStoreImpl<?, ?> store = new VersionedMapStoreImpl<>(auxiliaryData.getHashProvider(),
+                                                auxiliaryData.getDefaultValue());
+                                result.put(auxiliaryData, store);
                         } else {
                                 throw new UnsupportedOperationException(
                                                 "Model store does not have strategy to use " + dataRepresentation.getClass() + "!");
@@ -45,7 +46,7 @@ public class ModelStoreImpl implements ModelStore {
                 return result;
         }
 
-        private void initRepresentationGroup(Map<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> result,
+        private void initRepresentationGroup(Map<AnyDataRepresentation, VersionedMapStore<?, ?>> result,
                         List<Relation<?>> symbolGroup) {
                 final ContinousHashProvider<Tuple> hashProvider = symbolGroup.get(0).getHashProvider();
                 final Object defaultValue = symbolGroup.get(0).getDefaultValue();
@@ -70,14 +71,14 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public Set<DataRepresentation<?, ?>> getDataRepresentations() {
+        public Set<AnyDataRepresentation> getDataRepresentations() {
                 return this.stores.keySet();
         }
 
         @Override
         public ModelImpl createModel() {
-                Map<DataRepresentation<?, ?>, VersionedMap<?, ?>> maps = new HashMap<>();
-                for (Entry<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> entry : this.stores.entrySet()) {
+                Map<AnyDataRepresentation, VersionedMap<?, ?>> maps = new HashMap<>();
+                for (var entry : this.stores.entrySet()) {
                         maps.put(entry.getKey(), entry.getValue().createMap());
                 }
                 return new ModelImpl(this, maps);
@@ -85,8 +86,8 @@ public class ModelStoreImpl implements ModelStore {
 
         @Override
         public synchronized ModelImpl createModel(long state) {
-                Map<DataRepresentation<?, ?>, VersionedMap<?, ?>> maps = new HashMap<>();
-                for (Entry<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> entry : this.stores.entrySet()) {
+                Map<AnyDataRepresentation, VersionedMap<?, ?>> maps = new HashMap<>();
+                for (var entry : this.stores.entrySet()) {
                         maps.put(entry.getKey(), entry.getValue().createMap(state));
                 }
                 return new ModelImpl(this, maps);
@@ -103,10 +104,10 @@ public class ModelStoreImpl implements ModelStore {
 
         @Override
         public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
-                Map<DataRepresentation<?, ?>, DiffCursor<?, ?>> diffcursors = new HashMap<>();
-                for (Entry<DataRepresentation<?, ?>, VersionedMapStore<?, ?>> entry : stores.entrySet()) {
-                        DataRepresentation<?, ?> representation = entry.getKey();
-                        DiffCursor<?, ?> diffCursor = entry.getValue().getDiffCursor(from, to);
+                Map<AnyDataRepresentation, DiffCursor<?, ?>> diffcursors = new HashMap<>();
+                for (var entry : stores.entrySet()) {
+                        var representation = entry.getKey();
+                        var diffCursor = entry.getValue().getDiffCursor(from, to);
                         diffcursors.put(representation, diffCursor);
                 }
                 return new ModelDiffCursor(diffcursors);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index 2a5f2925..795a891b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -1,9 +1,5 @@
 package tools.refinery.store.model.internal;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
 import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
@@ -12,31 +8,41 @@ import tools.refinery.store.map.internal.MapDiffCursor;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
 import tools.refinery.store.model.representation.DataRepresentation;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
 public class ModelImpl implements Model {
         private final ModelStore store;
-        private final Map<DataRepresentation<?, ?>, VersionedMap<?, ?>> maps;
 
-        public ModelImpl(ModelStore store, Map<DataRepresentation<?, ?>, VersionedMap<?, ?>> maps) {
+        private final Map<AnyDataRepresentation, VersionedMap<?, ?>> maps;
+
+        public ModelImpl(ModelStore store, Map<AnyDataRepresentation, VersionedMap<?, ?>> maps) {
                 this.store = store;
                 this.maps = maps;
         }
 
         @Override
-        public Set<DataRepresentation<?, ?>> getDataRepresentations() {
+        public Set<AnyDataRepresentation> getDataRepresentations() {
                 return maps.keySet();
         }
 
-        @SuppressWarnings("unchecked")
-        private <K, V> VersionedMap<K, V> getMap(DataRepresentation<K, V> representation) {
+        private VersionedMap<?, ?> getMap(AnyDataRepresentation representation) {
                 if (maps.containsKey(representation)) {
-                        return (VersionedMap<K, V>) maps.get(representation);
+                        return maps.get(representation);
                 } else {
                         throw new IllegalArgumentException("Model does have representation " + representation);
                 }
         }
 
+        @SuppressWarnings("unchecked")
+        private <K, V> VersionedMap<K, V> getMap(DataRepresentation<K, V> representation) {
+                return (VersionedMap<K, V>) maps.get(representation);
+        }
+
         private <K, V> VersionedMap<K, V> getMapValidateKey(DataRepresentation<K, V> representation, K key) {
                 if (representation.isValidKey(key)) {
                         return getMap(representation);
@@ -67,17 +73,18 @@ public class ModelImpl implements Model {
         }
 
         @Override
-        public <K, V> long getSize(DataRepresentation<K, V> representation) {
+        public long getSize(AnyDataRepresentation representation) {
                 return getMap(representation).getSize();
         }
 
         @Override
         public ModelDiffCursor getDiffCursor(long to) {
                 Model toModel = store.createModel(to);
-                Map<DataRepresentation<?, ?>, DiffCursor<?, ?>> diffCursors = new HashMap<>();
-                for (DataRepresentation<?, ?> representation : this.maps.keySet()) {
-                        MapDiffCursor<?, ?> diffCursor = constructDiffCursor(toModel, representation);
-                        diffCursors.put(representation, diffCursor);
+                Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors = new HashMap<>();
+                for (AnyDataRepresentation anyDataRepresentation : this.maps.keySet()) {
+                        var dataRepresentation = (DataRepresentation<?, ?>) anyDataRepresentation;
+                        MapDiffCursor<?, ?> diffCursor = constructDiffCursor(toModel, dataRepresentation);
+                        diffCursors.put(dataRepresentation, diffCursor);
                 }
                 return new ModelDiffCursor(diffCursors);
         }
@@ -113,12 +120,12 @@ public class ModelImpl implements Model {
 
         @Override
         public void restore(long state) {
-                if(store.getStates().contains(state)) {
+                if (store.getStates().contains(state)) {
                         for (VersionedMap<?, ?> map : maps.values()) {
                                 map.restore(state);
                         }
                 } else {
-                        throw new IllegalArgumentException("Map does not contain state "+state+"!");
+                        throw new IllegalArgumentException("Map does not contain state " + state + "!");
                 }
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java
index 9939f17e..79e4c9f9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java
@@ -1,31 +1,33 @@
 package tools.refinery.store.model.internal;
 
-import java.util.Objects;
-
 import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
 
 public class SimilarRelationEquivalenceClass {
         final ContinousHashProvider<Tuple> hashProvider;
         final Object defaultValue;
         final int arity;
+
         public SimilarRelationEquivalenceClass(Relation<?> representation) {
                 this.hashProvider = representation.getHashProvider();
                 this.defaultValue = representation.getDefaultValue();
                 this.arity = representation.getArity();
         }
+
         @Override
         public int hashCode() {
                 return Objects.hash(arity, defaultValue, hashProvider);
         }
+
         @Override
         public boolean equals(Object obj) {
                 if (this == obj)
                         return true;
-                if (!(obj instanceof SimilarRelationEquivalenceClass))
+                if (!(obj instanceof SimilarRelationEquivalenceClass other))
                         return false;
-                SimilarRelationEquivalenceClass other = (SimilarRelationEquivalenceClass) obj;
                 return arity == other.arity && Objects.equals(defaultValue, other.defaultValue)
                                 && Objects.equals(hashProvider, other.hashProvider);
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java
new file mode 100644
index 00000000..951952e5
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java
@@ -0,0 +1,4 @@
+package tools.refinery.store.model.representation;
+
+public sealed interface AnyAuxiliaryData extends AnyDataRepresentation permits AuxiliaryData {
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java
new file mode 100644
index 00000000..ea74a625
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.model.representation;
+
+public sealed interface AnyDataRepresentation permits DataRepresentation, AnyRelation, AnyAuxiliaryData {
+        String getName();
+
+        Class<?> getKeyType();
+
+        Class<?> getValueType();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java
new file mode 100644
index 00000000..1d698c28
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.model.representation;
+
+import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.tuple.Tuple;
+
+public sealed interface AnyRelation extends AnyDataRepresentation, RelationLike permits Relation {
+        @Override
+        Class<Tuple> getKeyType();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
index 18c38151..dad1ccf4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
@@ -2,7 +2,7 @@ package tools.refinery.store.model.representation;
 
 import tools.refinery.store.map.ContinousHashProvider;
 
-public final class AuxiliaryData<K, V> extends DataRepresentation<K, V> {
+public final class AuxiliaryData<K, V> extends DataRepresentation<K, V> implements AnyAuxiliaryData {
         private final ContinousHashProvider<K> hashProvider;
 
         public AuxiliaryData(String name, Class<K> keyType, ContinousHashProvider<K> hashProvider, Class<V> valueType,
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
index 61c6291b..2bf498b9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
@@ -2,7 +2,7 @@ package tools.refinery.store.model.representation;
 
 import tools.refinery.store.map.ContinousHashProvider;
 
-public abstract sealed class DataRepresentation<K, V> permits Relation, AuxiliaryData {
+public abstract sealed class DataRepresentation<K, V> implements AnyDataRepresentation permits Relation, AuxiliaryData {
         private final String name;
 
         private final V defaultValue;
@@ -18,6 +18,7 @@ public abstract sealed class DataRepresentation<K, V> permits Relation, Auxiliar
                 this.valueType = valueType;
         }
 
+        @Override
         public String getName() {
                 return name;
         }
@@ -30,10 +31,12 @@ public abstract sealed class DataRepresentation<K, V> permits Relation, Auxiliar
                 return defaultValue;
         }
 
+        @Override
         public Class<K> getKeyType() {
                 return keyType;
         }
 
+        @Override
         public Class<V> getValueType() {
                 return valueType;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
index cc32257c..47a07536 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
@@ -1,11 +1,10 @@
 package tools.refinery.store.model.representation;
 
 import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.model.RelationLike;
 import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.tuple.Tuple;
 
-public final class Relation<D> extends DataRepresentation<Tuple, D> implements RelationLike {
+public final class Relation<D> extends DataRepresentation<Tuple, D> implements AnyRelation {
         private final int arity;
 
         public Relation(String name, int arity, Class<D> valueType, D defaultValue) {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
index 41f47e64..3a69f3a4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
@@ -1,17 +1,15 @@
 package tools.refinery.store.query;
 
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.representation.DataRepresentation;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.model.representation.AnyDataRepresentation;
+import tools.refinery.store.query.view.AnyRelationView;
 
 import java.util.Set;
 
 public interface QueryableModelStore extends ModelStore {
-        @SuppressWarnings("squid:S1452")
-        Set<DataRepresentation<?, ?>> getDataRepresentations();
+    Set<AnyDataRepresentation> getDataRepresentations();
 
-        @SuppressWarnings("squid:S1452")
-        Set<RelationView<?>> getViews();
+        Set<AnyRelationView> getViews();
 
         Set<DNF> getPredicates();
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
index bc107b76..e389f563 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
@@ -7,6 +7,14 @@ public enum Modality {
         MAY,
         CURRENT;
 
+        public Modality negate() {
+                return switch(this) {
+                        case MUST -> MAY;
+                        case MAY -> MUST;
+                        case CURRENT -> CURRENT;
+                };
+        }
+
         @Override
         public String toString() {
                 return name().toLowerCase(Locale.ROOT);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
index 762a41f1..cf836541 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
@@ -1,17 +1,17 @@
 package tools.refinery.store.query.atom;
 
 import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.AnyRelationView;
 
 import java.util.List;
 import java.util.Objects;
 
-public final class RelationViewAtom extends AbstractSubstitutionAtom<RelationView<?>> {
-        public RelationViewAtom(RelationView<?> target, List<Variable> substitution) {
+public final class RelationViewAtom extends AbstractSubstitutionAtom<AnyRelationView> {
+        public RelationViewAtom(AnyRelationView target, List<Variable> substitution) {
                 super(target, substitution);
         }
 
-        public RelationViewAtom(RelationView<?> target, Variable... substitution) {
+        public RelationViewAtom(AnyRelationView target, Variable... substitution) {
                 this(target, List.of(substitution));
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
new file mode 100644
index 00000000..df5e0d72
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
@@ -0,0 +1,13 @@
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.model.representation.AnyRelation;
+
+public sealed interface AnyRelationView extends RelationLike permits RelationView {
+        AnyRelation getRepresentation();
+
+        boolean get(Model model, Object[] tuple);
+
+        Iterable<Object[]> getAll(Model model);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
index 3b639979..5b892cc6 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
@@ -3,6 +3,7 @@ package tools.refinery.store.query.view;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
 
+import java.util.Objects;
 import java.util.function.BiPredicate;
 import java.util.function.Predicate;
 
@@ -31,4 +32,18 @@ public class FilteredRelationView<D> extends AbstractFilteredRelationView<D> {
         public boolean filter(Tuple key, D value) {
                 return this.predicate.test(key, value);
         }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                if (!super.equals(o)) return false;
+                FilteredRelationView<?> that = (FilteredRelationView<?>) o;
+                return Objects.equals(predicate, that.predicate);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), predicate);
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
index c88af5a4..f7e7d28a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
@@ -3,6 +3,8 @@ package tools.refinery.store.query.view;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
 
+import java.util.Objects;
+
 public class KeyOnlyRelationView extends AbstractFilteredRelationView<Boolean> {
         public static final String VIEW_NAME = "key";
 
@@ -17,4 +19,18 @@ public class KeyOnlyRelationView extends AbstractFilteredRelationView<Boolean> {
         public boolean filter(Tuple key, Boolean value) {
                 return !value.equals(defaultValue);
         }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                if (!super.equals(o)) return false;
+                KeyOnlyRelationView that = (KeyOnlyRelationView) o;
+                return Objects.equals(defaultValue, that.defaultValue);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), defaultValue);
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
index 96f8584a..1224076c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
@@ -2,9 +2,8 @@ package tools.refinery.store.query.view;
 
 import tools.refinery.store.map.CursorAsIterator;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Objects;
 import java.util.UUID;
@@ -15,7 +14,7 @@ import java.util.UUID;
  * @param <D>
  * @author Oszkar Semerath
  */
-public abstract class RelationView<D> implements RelationLike {
+public abstract non-sealed class RelationView<D> implements AnyRelationView {
         private final Relation<D> representation;
 
         private final String name;
@@ -29,6 +28,7 @@ public abstract class RelationView<D> implements RelationLike {
                 this(representation, UUID.randomUUID().toString());
         }
 
+        @Override
         public Relation<D> getRepresentation() {
                 return representation;
         }
@@ -42,28 +42,21 @@ public abstract class RelationView<D> implements RelationLike {
 
         public abstract Object[] forwardMap(Tuple key, D value);
 
-        public abstract boolean get(Model model, Object[] tuple);
-
+        @Override
         public Iterable<Object[]> getAll(Model model) {
                 return (() -> new CursorAsIterator<>(model.getAll(representation), this::forwardMap, this::filter));
         }
 
         @Override
-        public int hashCode() {
-                final int prime = 31;
-                int result = 1;
-                result = prime * result + Objects.hash(representation);
-                return result;
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                RelationView<?> that = (RelationView<?>) o;
+                return Objects.equals(representation, that.representation) && Objects.equals(name, that.name);
         }
 
         @Override
-        public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (!(obj instanceof RelationView))
-                        return false;
-                @SuppressWarnings("unchecked")
-                RelationView<D> other = ((RelationView<D>) obj);
-                return Objects.equals(representation, other.representation);
+        public int hashCode() {
+                return Objects.hash(representation, name);
         }
 }