Change ListIota to use Vector

s5bug · Sirius902 · s5bug · commit 012e07e8fae3 · 2025-07-13T20:23:33.000-07:00
Co-authored-by: Sirius902 &lt;10891979+Sirius902@users.noreply.github.com&gt;
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/ActionUtils.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/ActionUtils.kt
@@ -6,6 +6,7 @@ import at.petrak.hexcasting.api.casting.iota.*
 import at.petrak.hexcasting.api.casting.math.HexPattern
 import at.petrak.hexcasting.api.casting.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughArgs
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.api.utils.asTranslatedComponent
 import com.mojang.datafixers.util.Either
 import net.minecraft.core.BlockPos
@@ -41,7 +42,7 @@ fun List<Iota>.getEntity(idx: Int, argc: Int = 0): Entity {
     }
 }
 
-fun List<Iota>.getList(idx: Int, argc: Int = 0): SpellList {
+fun List<Iota>.getList(idx: Int, argc: Int = 0): Vector<Iota> {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is ListIota) {
         return x.list
@@ -269,7 +270,7 @@ fun List<Iota>.getNumOrVec(idx: Int, argc: Int = 0): Either<Double, Vec3> {
     }
 }
 
-fun List<Iota>.getLongOrList(idx: Int, argc: Int = 0): Either<Long, SpellList> {
+fun List<Iota>.getLongOrList(idx: Int, argc: Int = 0): Either<Long, Vector<Iota>> {
     val datum = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (datum is DoubleIota) {
         val double = datum.double
@@ -287,7 +288,7 @@ fun List<Iota>.getLongOrList(idx: Int, argc: Int = 0): Either<Long, SpellList> {
     )
 }
 
-fun evaluatable(datum: Iota, reverseIdx: Int): Either<Iota, SpellList> =
+fun evaluatable(datum: Iota, reverseIdx: Int): Either<Iota, Vector<Iota>> =
     when (datum) {
         is ListIota -> Either.right(datum.list)
         else -> if (datum.executable()) Either.left(datum) else throw MishapInvalidIota(
@@ -312,8 +313,8 @@ inline val Boolean.asActionResult get() = listOf(BooleanIota(this))
 inline val Double.asActionResult get() = listOf(DoubleIota(this))
 inline val Number.asActionResult get() = listOf(DoubleIota(this.toDouble()))
 
-inline val SpellList.asActionResult get() = listOf(ListIota(this))
-inline val List<Iota>.asActionResult get() = listOf(ListIota(this))
+inline val SpellList.asActionResult get() = listOf(ListIota(Vector.from(this)))
+inline val List<Iota>.asActionResult get() = listOf(ListIota(Vector.from(this)))
 
 inline val BlockPos.asActionResult get() = listOf(Vec3Iota(Vec3.atCenterOf(this)))
 inline val Vector3f.asActionResult get() = listOf(Vec3Iota(Vec3(this)))
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingImage.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingImage.kt
@@ -45,7 +45,7 @@ data class CastingImage private constructor(
             tag.put(TAG_IOTAS, ListTag())
             tag.put(TAG_ESCAPED, ListTag())
         } else {
-            tag.put(TAG_IOTAS, ListIota(this.map { it.iota }).serialize())
+            tag.put(TAG_IOTAS, ListIota(Vector.from(this).map { it.iota }).serialize())
             tag.put(TAG_ESCAPED, this.map { it.escaped }.serializeToNBT())
         }
 
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingVM.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingVM.kt
@@ -219,7 +219,7 @@ class CastingVM(var image: CastingImage, val env: CastingEnvironment) {
                         displayDepth--
                         if (newParenCount == 0) {
                             val newStack = this.image.stack.toMutableList()
-                            newStack.add(ListIota(this.image.parenthesized.toList().map { it.iota }))
+                            newStack.add(ListIota(Vector.from(this.image.parenthesized.toList().map { it.iota })))
                             this.image.copy(
                                 stack = newStack,
                                 parenCount = newParenCount,
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/FrameEvaluate.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/FrameEvaluate.kt
@@ -6,6 +6,7 @@ import at.petrak.hexcasting.api.casting.eval.ResolvedPatternType
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.utils.NBTBuilder
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.api.utils.getList
 import at.petrak.hexcasting.api.utils.serializeToNBT
 import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
@@ -44,7 +45,7 @@ data class FrameEvaluate(val list: SpellList, val isMetacasting: Boolean) : Cont
             }
         } else {
             // If there are no patterns (e.g. empty Hermes), just return OK.
-            CastResult(ListIota(list), continuation, null, listOf(), ResolvedPatternType.EVALUATED, HexEvalSounds.HERMES)
+            CastResult(ListIota(Vector.from(list)), continuation, null, listOf(), ResolvedPatternType.EVALUATED, HexEvalSounds.HERMES)
         }
     }
 
@@ -62,10 +63,10 @@ data class FrameEvaluate(val list: SpellList, val isMetacasting: Boolean) : Cont
         val TYPE: ContinuationFrame.Type<FrameEvaluate> = object : ContinuationFrame.Type<FrameEvaluate> {
             override fun deserializeFromNBT(tag: CompoundTag, world: ServerLevel): FrameEvaluate {
                 return FrameEvaluate(
-                    HexIotaTypes.LIST.deserialize(
+                    SpellList.LList(0, HexIotaTypes.LIST.deserialize(
                         tag.getList("patterns", Tag.TAG_COMPOUND),
                         world
-                    )!!.list,
+                    )!!.list),
                     tag.getBoolean("isMetacasting"))
             }
 
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/FrameForEach.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/FrameForEach.kt
@@ -69,7 +69,7 @@ data class FrameForEach(
         val tStack = stack.toMutableList()
         tStack.add(stackTop)
         return CastResult(
-            ListIota(code),
+            ListIota(Vector.from(code)),
             newCont,
             // reset escapes so they don't carry over to other iterations or out of thoth
             newImage.withResetEscape().copy(stack = tStack),
@@ -96,8 +96,8 @@ data class FrameForEach(
         val TYPE: ContinuationFrame.Type<FrameForEach> = object : ContinuationFrame.Type<FrameForEach> {
             override fun deserializeFromNBT(tag: CompoundTag, world: ServerLevel): FrameForEach {
                 return FrameForEach(
-                    HexIotaTypes.LIST.deserialize(tag.getList("data", Tag.TAG_COMPOUND), world)!!.list,
-                    HexIotaTypes.LIST.deserialize(tag.getList("code", Tag.TAG_COMPOUND), world)!!.list,
+                    SpellList.LList(0, HexIotaTypes.LIST.deserialize(tag.getList("data", Tag.TAG_COMPOUND), world)!!.list),
+                    SpellList.LList(0, HexIotaTypes.LIST.deserialize(tag.getList("code", Tag.TAG_COMPOUND), world)!!.list),
                     if (tag.hasList("base", Tag.TAG_COMPOUND))
                         HexIotaTypes.LIST.deserialize(tag.getList("base", Tag.TAG_COMPOUND), world)!!.list.toList()
                     else
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java
@@ -1,7 +1,7 @@
 package at.petrak.hexcasting.api.casting.iota;
 
-import at.petrak.hexcasting.api.casting.SpellList;
 import at.petrak.hexcasting.api.utils.HexUtils;
+import at.petrak.hexcasting.api.utils.Vector;
 import at.petrak.hexcasting.common.lib.hex.HexIotaTypes;
 import net.minecraft.ChatFormatting;
 import net.minecraft.nbt.CompoundTag;
@@ -12,19 +12,18 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Iterator;
 
 import static java.lang.Math.max;
 
 /**
- * This is a <i>wrapper</i> for {@link SpellList}.
+ * This is a <i>wrapper</i> for {@link Vector<Iota>}.
  */
 public class ListIota extends Iota {
     private final int depth;
     private final int size;
 
-    public ListIota(@NotNull SpellList list) {
+    public ListIota(@NotNull Vector<Iota> list) {
         super(HexIotaTypes.LIST, list);
         int maxChildDepth = 0;
         int totalSize = 1;
@@ -36,17 +35,13 @@ public ListIota(@NotNull SpellList list) {
         size = totalSize;
     }
 
-    public ListIota(@NotNull List<Iota> list) {
-        this(new SpellList.LList(list));
-    }
-
-    public SpellList getList() {
-        return (SpellList) this.payload;
+    public Vector<Iota> getList() {
+        return (Vector<Iota>) this.payload;
     }
 
     @Override
     public boolean isTruthy() {
-        return this.getList().getNonEmpty();
+        return !this.getList().isEmpty();
     }
 
     @Override
@@ -60,7 +55,7 @@ public boolean toleratesOther(Iota that) {
         }
         var b = list.getList();
 
-        SpellList.SpellListIterator aIter = a.iterator(), bIter = b.iterator();
+        Iterator<Iota> aIter = a.iterator(), bIter = b.iterator();
         for (; ; ) {
             if (!aIter.hasNext() && !bIter.hasNext()) {
                 // we ran out together!
@@ -106,18 +101,18 @@ public int depth() {
         @Override
         public ListIota deserialize(Tag tag, ServerLevel world) throws IllegalArgumentException {
             var listTag = HexUtils.downcast(tag, ListTag.TYPE);
-            var out = new ArrayList<Iota>(listTag.size());
+            var out = new Vector.VectorBuilder<Iota>();
 
             for (var sub : listTag) {
                 var csub = HexUtils.downcast(sub, CompoundTag.TYPE);
                 var subiota = IotaType.deserialize(csub, world);
                 if (subiota == null) {
                     return null;
                 }
-                out.add(subiota);
+                out.addOne(subiota);
             }
 
-            return new ListIota(out);
+            return new ListIota(out.result());
         }
 
         @Override
diff --git a/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt b/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt
@@ -265,7 +265,7 @@ fun Iterable<Iota>.serializeToNBT() =
     if (IotaType.isTooLargeToSerialize(this))
         ListTag()
     else
-        ListIota(this.toList()).serialize()
+        ListIota(Vector.from(this)).serialize()
 
 fun Iterable<Boolean>.serializeToNBT(): ByteArrayTag {
     val out = ByteArray(if (this is Collection<*>) this.size else 10)
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/eval/OpEval.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/eval/OpEval.kt
@@ -30,7 +30,7 @@ object OpEval : Action {
                     continuation.pushFrame(FrameFinishEval) // install a break-boundary after eval
                 }
 
-        val instrsList = instrs.map({ SpellList.LList(0, listOf(it)) }, { it })
+        val instrsList = instrs.map({ SpellList.LList(0, listOf(it)) }, { SpellList.LList(0, it) })
         val frame = FrameEvaluate(instrsList, true)
 
         val image2 = image.withUsedOp().copy(stack = newStack)
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/eval/OpForEach.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/eval/OpForEach.kt
@@ -1,13 +1,13 @@
 package at.petrak.hexcasting.common.casting.actions.eval
 
+import at.petrak.hexcasting.api.casting.SpellList
 import at.petrak.hexcasting.api.casting.castables.Action
 import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
 import at.petrak.hexcasting.api.casting.eval.OperationResult
 import at.petrak.hexcasting.api.casting.eval.vm.CastingImage
 import at.petrak.hexcasting.api.casting.eval.vm.FrameForEach
 import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
 import at.petrak.hexcasting.api.casting.getList
-import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughArgs
 import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
@@ -24,7 +24,7 @@ object OpForEach : Action {
         stack.removeLastOrNull()
         stack.removeLastOrNull()
 
-        val frame = FrameForEach(datums, instrs, null, Vector.empty<Iota>())
+        val frame = FrameForEach(SpellList.LList(0, datums), SpellList.LList(0, instrs), null, Vector.empty())
         val image2 = image.withUsedOp().copy(stack = stack)
 
         return OperationResult(image2, listOf(), continuation.pushFrame(frame), HexEvalSounds.THOTH)
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpCons.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpCons.kt
@@ -12,6 +12,6 @@ object OpCons : ConstMediaAction {
     override fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota> {
         val bottom = args.getList(0, argc)
         val top = args[1]
-        return SpellList.LPair(top, bottom).asActionResult
+        return SpellList.LPair(top, SpellList.LList(0, bottom)).asActionResult
     }
 }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpModifyInPlace.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpModifyInPlace.kt
@@ -12,8 +12,8 @@ object OpModifyInPlace : ConstMediaAction {
     override val argc = 3
     override fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota> {
         val list = args.getList(0, argc)
-        val index = args.getPositiveIntUnder(1, list.size(), argc)
+        val index = args.getPositiveIntUnder(1, list.size, argc)
         val iota = args[2]
-        return list.modifyAt(index) { SpellList.LPair(iota, it.cdr) }.asActionResult
+        return SpellList.LList(0, list).modifyAt(index) { SpellList.LPair(iota, it.cdr) }.asActionResult
     }
 }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpUnCons.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/lists/OpUnCons.kt
@@ -1,18 +1,20 @@
 package at.petrak.hexcasting.common.casting.actions.lists
 
+import at.petrak.hexcasting.api.casting.SpellList
 import at.petrak.hexcasting.api.casting.castables.ConstMediaAction
 import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
 import at.petrak.hexcasting.api.casting.getList
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.casting.iota.NullIota
+import at.petrak.hexcasting.api.utils.Vector
 
 object OpUnCons : ConstMediaAction {
     override val argc = 1
     override fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota> {
-        val list = args.getList(0, argc)
+        val list = SpellList.LList(0, args.getList(0, argc))
         if (list.nonEmpty) {
-            return listOf(ListIota(list.cdr), list.car)
+            return listOf(ListIota(Vector.from(list.cdr)), list.car)
         }
         return listOf(args[0], NullIota())
     }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/ListArithmetic.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/ListArithmetic.kt
@@ -15,6 +15,7 @@ import at.petrak.hexcasting.api.casting.iota.DoubleIota
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.casting.math.HexPattern
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.casting.arithmetic.operator.list.*
 import at.petrak.hexcasting.common.lib.hex.HexIotaTypes.LIST
 import java.util.function.BinaryOperator
@@ -45,20 +46,20 @@ object ListArithmetic : Arithmetic {
             SLICE -> OperatorSlice
             APPEND -> OperatorAppend
             UNAPPEND -> OperatorUnappend
-            ADD -> make2 { list0, list1 -> list0 + list1 }
-            ABS -> OperatorUnary(all(IotaPredicate.ofType(LIST))) { iota: Iota -> DoubleIota(downcast(iota, LIST).list.size().toDouble()) }
-            REV -> OperatorUnary(all(IotaPredicate.ofType(LIST))) { iota: Iota -> ListIota(downcast(iota, LIST).list.toList().asReversed()) }
+            ADD -> make2 { list0, list1 -> list0.appendedAll(list1) }
+            ABS -> OperatorUnary(all(IotaPredicate.ofType(LIST))) { iota: Iota -> DoubleIota(downcast(iota, LIST).list.size.toDouble()) }
+            REV -> OperatorUnary(all(IotaPredicate.ofType(LIST))) { iota: Iota -> ListIota(downcast(iota, LIST).list.reversed()) }
             INDEX_OF -> OperatorIndexOf
             REMOVE -> OperatorRemove
             REPLACE -> OperatorReplace
-            CONS -> OperatorBinary(pair(IotaPredicate.ofType(LIST), IotaPredicate.TRUE)) { list, iota -> ListIota(SpellList.LPair(iota, downcast(list, LIST).list)) }
+            CONS -> OperatorBinary(pair(IotaPredicate.ofType(LIST), IotaPredicate.TRUE)) { list, iota -> ListIota(downcast(list, LIST).list.prepended(iota)) }
             UNCONS -> OperatorUnCons
             else -> throw InvalidOperatorException("$pattern is not a valid operator in Arithmetic $this.")
         }
     }
 
-    private fun make2(op: BinaryOperator<List<Iota>>): OperatorBinary = OperatorBinary(all(IotaPredicate.ofType(LIST)))
+    private fun make2(op: BinaryOperator<Vector<Iota>>): OperatorBinary = OperatorBinary(all(IotaPredicate.ofType(LIST)))
     { i: Iota, j: Iota -> ListIota(
-            op.apply(downcast(i, LIST).list.toList(), downcast(j, LIST).list.toList())
+        op.apply(downcast(i, LIST).list, downcast(j, LIST).list)
     ) }
 }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/ListSetArithmetic.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/ListSetArithmetic.kt
@@ -11,6 +11,7 @@ import at.petrak.hexcasting.api.casting.arithmetic.predicates.IotaPredicate
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.casting.math.HexPattern
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.casting.arithmetic.operator.list.OperatorUnique
 import at.petrak.hexcasting.common.lib.hex.HexIotaTypes.LIST
 import java.util.function.BinaryOperator
@@ -29,15 +30,15 @@ object ListSetArithmetic : Arithmetic {
 
     override fun getOperator(pattern: HexPattern): Operator = when (pattern) {
         AND -> make2 { list0, list1 -> list0.filter { x -> list1.any { Iota.tolerates(x, it) } } }
-        OR -> make2 { list0, list1 -> list0 + list1.filter { x -> list0.none { Iota.tolerates(x, it) } } }
-        XOR -> make2 { list0, list1 -> list0.filter { x0 -> list1.none {Iota.tolerates(x0, it) } } + list1.filter { x1 -> list0.none { Iota.tolerates(x1, it) } } }
+        OR -> make2 { list0, list1 -> list0.appendedAll(list1.filter { x -> !list0.exists { Iota.tolerates(x, it) } }) }
+        XOR -> make2 { list0, list1 -> list0.filter { x0 -> !list1.exists {Iota.tolerates(x0, it) } }.appendedAll(list1.filter { x1 -> !list0.exists { Iota.tolerates(x1, it) } }) }
         UNIQUE -> OperatorUnique
         else -> throw InvalidOperatorException("$pattern is not a valid operator in Arithmetic $this.")
     }
 
 
-    private fun make2(op: BinaryOperator<List<Iota>>): OperatorBinary = OperatorBinary(all(IotaPredicate.ofType(LIST)))
+    private fun make2(op: BinaryOperator<Vector<Iota>>): OperatorBinary = OperatorBinary(all(IotaPredicate.ofType(LIST)))
     { i: Iota, j: Iota -> ListIota(
-            op.apply(downcast(i, LIST).list.toList(), downcast(j, LIST).list.toList())
+        op.apply(downcast(i, LIST).list, downcast(j, LIST).list)
         ) }
 }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/OperatorUtils.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/OperatorUtils.kt
@@ -11,7 +11,7 @@ import kotlin.math.roundToInt
 fun Iterator<IndexedValue<Iota>>.nextList(argc: Int = 0): SpellList {
     val (idx, x) = this.next()
     if (x is ListIota) {
-        return x.list
+        return SpellList.LList(0, x.list)
     } else {
         throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "list")
     }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/list/OperatorUnCons.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/list/OperatorUnCons.kt
@@ -8,6 +8,7 @@ import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.casting.iota.NullIota
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.casting.arithmetic.operator.nextList
 import at.petrak.hexcasting.common.lib.hex.HexIotaTypes.LIST
 
@@ -16,7 +17,7 @@ object OperatorUnCons : OperatorBasic(1, IotaMultiPredicate.all(IotaPredicate.of
         val it = iotas.iterator().withIndex()
         val list = it.nextList(arity)
         if (list.nonEmpty)
-            return listOf(ListIota(list.cdr), list.car)
-        return listOf(ListIota(list), NullIota())
+            return listOf(ListIota(Vector.from(list.cdr)), list.car)
+        return listOf(ListIota(Vector.from(list)), NullIota())
     }
 }
diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/list/OperatorUnappend.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/arithmetic/operator/list/OperatorUnappend.kt
@@ -8,6 +8,7 @@ import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.ListIota
 import at.petrak.hexcasting.api.casting.iota.NullIota
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.casting.arithmetic.operator.nextList
 import at.petrak.hexcasting.common.lib.hex.HexIotaTypes.*
 
@@ -16,6 +17,6 @@ object OperatorUnappend : OperatorBasic(1, IotaMultiPredicate.all(IotaPredicate.
         val it = iotas.iterator().withIndex()
         val list = it.nextList(arity).toMutableList()
         val last = list.removeLastOrNull() ?: NullIota()
-        return listOf(ListIota(list), last)
+        return listOf(ListIota(Vector.from(list)), last)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ data class CastingImage private constructor(`
`45`	`45`	`tag.put(TAG_IOTAS, ListTag())`
`46`	`46`	`tag.put(TAG_ESCAPED, ListTag())`
`47`	`47`	`} else {`
`48`		`- tag.put(TAG_IOTAS, ListIota(this.map { it.iota }).serialize())`
	`48`	`+ tag.put(TAG_IOTAS, ListIota(Vector.from(this).map { it.iota }).serialize())`
`49`	`49`	`tag.put(TAG_ESCAPED, this.map { it.escaped }.serializeToNBT())`
`50`	`50`	`}`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ object OpEval : Action {`
`30`	`30`	`continuation.pushFrame(FrameFinishEval) // install a break-boundary after eval`
`31`	`31`	`}`
`32`	`32`
`33`		`- val instrsList = instrs.map({ SpellList.LList(0, listOf(it)) }, { it })`
	`33`	`+ val instrsList = instrs.map({ SpellList.LList(0, listOf(it)) }, { SpellList.LList(0, it) })`
`34`	`34`	`val frame = FrameEvaluate(instrsList, true)`
`35`	`35`
`36`	`36`	`val image2 = image.withUsedOp().copy(stack = newStack)`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,6 @@ object OpCons : ConstMediaAction {`
`12`	`12`	`override fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota> {`
`13`	`13`	`val bottom = args.getList(0, argc)`
`14`	`14`	`val top = args[1]`
`15`		`- return SpellList.LPair(top, bottom).asActionResult`
	`15`	`+ return SpellList.LPair(top, SpellList.LList(0, bottom)).asActionResult`
`16`	`16`	`}`
`17`	`17`	`}`