tuProlog/2p-kt

Description ceiling/1 (solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/stdlib/function/Ceiling.kt) converts its result through Double.toLong(), which saturates at Long.MAX_VALUE, while floor/1, round/1 and truncate/1 correctly return big integers. Steps to reproduce ?- X is ceiling(1.0e30). ?- X is floor(1.0e30). Actual output X = 9223372036854775807. X = 1000000000000000000000000000000. Expected output X = 1000000000000000000000000000000. for both.

Context AbstractIterableItems<T : Any> (oop-lib/src/commonMain/kotlin/it/unibo/tuprolog/solve/libs/oop/primitives/AbstractIterableItems.kt) is the shared base of the array_items/2, list_items/2 and set_items/2 primitives (ArrayItems, ListItems, SetItems in the same package). Its constructor takes a private val target: KClass<T>, and each subclass passes one (Array::class, List::class, Set::class). Problem target is stored but never read. The runtime type check it could perform is instead duplicated by hand in every subclass, through the abstract Any?.isIterable property (this is Array<*>, this is List<*>, this is Set<*>), and the base class then does an unchecked cast obj as T. Still the case on current master. Possible approaches Remove it: drop the target parameter from AbstractIterableItems and from the three subclasses. This is the smallest change and doesn't change behaviour. Use it: give isIterable a default implementation, target.isInstance(this), and drop the three overrides (

Context Solve.Request<C>.getArgumentAsTypeRef(index: Int) in oop-lib/src/commonMain/kotlin/it/unibo/tuprolog/solve/libs/oop/primitives/PrimitiveExtensions.kt resolves the argument at position index into a TypeRef (a TypeRef term, an atom naming a type, or a de-aliasing expression). When none of those cases match, the fallback branch raises the type error by calling: else -> { ensuringArgumentIsTypeRef(1) // hardcoded 1, should be `index` null } Actual vs expected Actual: the error check always inspects argument 1, regardless of index. Callers: NewObject3 (new_object/3) calls getArgumentAsTypeRef(0): if argument 0 is not a valid type reference, the check looks at argument 1 instead. That argument is the constructor-argument list, so the error names the wrong argument and the wrong culprit term. If argument 1 happens to pass the check, no error is raised at all, and the primitive just fails silently (null leads to Substitution.failed()). Cast (cast/3) calls getArgumentAsTypeR

Context TheoryDeobjectifier (module :serialize-theory) turns a plain object (as parsed from JSON/YAML) into a Theory. Both platform implementations delegate to TermDeobjectifier.default.deobjectifyMany(...) and then blindly cast every resulting term to Clause: serialize-theory/src/jvmMain/kotlin/it/unibo/tuprolog/serialize/JvmTheoryDeobjectifier.kt serialize-theory/src/jsMain/kotlin/it/unibo/tuprolog/serialize/JsTheoryDeobjectifier.kt TermDeobjectifier.default .deobjectifyMany(`object`) .asSequence() .map { it as Clause } // <-- raw ClassCastException on non-clause terms Actual behaviour If a list element is a well-formed term that is not a clause (e.g. an atom, a number, a variable, or a struct objectified without the head/body shape), the unchecked cast throws a raw ClassCastException (lazily, while Theory.of consumes the sequence). Expected behaviour Malformed input should be signalled with DeobjectificationException (serialize-core/src/commonMain/kotlin/it/unibo/tup

Context Runtime (the library group held by every solver) supports removing libraries via three minus overloads, implemented in solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/library/impl/RuntimeImpl.kt: minus(library: Library) minus(alias: String) minus(aliases: Iterable<String>) Actual behaviour All three overloads have the guard inverted: override operator fun minus(alias: String): RuntimeImpl { if (alias in aliases) { // <- should be `!in` noSuchALibraryError(alias) } return RuntimeImpl(libraries.asSequence().filter { it.alias != alias }) } So removing a library that is loaded throws NoSuchALibraryException, while removing one that is not loaded silently returns an unchanged runtime. In practice, runtime - "prolog.lang" (or runtime - someLoadedLibrary) can never succeed. Expected behaviour Consistent with the exception name and with update(library) (which throws when the alias is not loaded): removing a loaded library returns a Runtime without it