DEV Community: Kotools

🚀 What's new in Kotools Types 5.2.0

Kotools — Fri, 03 Jul 2026 15:44:02 +0000

Kotools Types 5.2.0 is out, and it's the biggest release yet for org.kotools.types.number. Four changes stand out. Each gets its own dedicated, deep-dive article — this post is the short tour.

🧮 `Integer` got a faster internal representation

Before 5.2.0, Integer stored its value as a String and reparsed it on every arithmetic operation. That representation is gone: Integer now delegates to java.lang.BigInteger on Kotlin/JVM, BigInt on Kotlin/JS, and a custom arbitrary-precision implementation on Kotlin/Native — with no parsing involved in +, -, *, div, or rem. This was one of the most frequently requested changes from the community.

🎯 `Decimal` arrives: exact arithmetic without floating-point

0.1 + 0.2 != 0.3 is a classic trap with Double/Float, because binary floating-point can't exactly represent most base-10 decimals. Decimal, a brand-new type in org.kotools.types.number, sidesteps the problem entirely by never using floating-point in the first place — addition, subtraction, and multiplication are always exact.

➗ `Integer` division is now Euclidean, and total

Integer.div and Integer.rem now always satisfy 0 <= remainder < |divisor| — no more negative remainders depending on the sign of the operands. The divisor is also now a NonZeroInteger, a type that rules out division by zero at compile time, so these operations can no longer throw or return null because of a zero divisor.

🔒 Sign as a type: `NonZeroInteger`, `NonNegativeInteger`, `NonPositiveInteger`

Three new types turn "this integer can never be negative" (or positive, or zero) from a runtime check into a compile-time guarantee, with arithmetic operators that preserve those guarantees across additions and multiplications.

🛠️ Adding Kotools Types to your project

See the Installation section of the project's README for Gradle/Maven setup — this article was written against version 5.2.0.

This API is @ExperimentalKotoolsTypesApi, so opt in either per call-site with @OptIn(ExperimentalKotoolsTypesApi::class) or project-wide via the compiler argument:

// build.gradle.kts
kotlin {
    compilerOptions {
        freeCompilerArgs.add("-opt-in=org.kotools.types.ExperimentalKotoolsTypesApi")
    }
}

💬 Discussion

Which of these four changes affects your code the most?

⚠️ The Kotlin Multiplatform division-by-zero trap

Kotools — Sat, 13 Jun 2026 12:40:04 +0000

If you write Kotlin Multiplatform code that involves integer division, you may have already hit this: the exact same expression behaves completely differently depending on which platform compiles it.

🐛 The problem

Take this innocuous expression:

val quotient = 12 / 0
val remainder = 12 % 0

On JVM and Native, both lines throw an ArithmeticException. That is the behavior most Kotlin developers expect and design around.

On JavaScript, both lines execute without any exception and silently return 0.

Here is a concrete illustration drawn directly from the Kotlin test suites for each platform:

// Kotlin/JS
check(12 / 0 == 0)   // passes — no exception
check(12 % 0 == 0)   // passes — no exception

// Kotlin/JVM and Kotlin/Native
val quotient: Result<Int> = runCatching { 12 / 0 }
val remainder: Result<Int> = runCatching { 12 % 0 }
check(quotient.exceptionOrNull() is ArithmeticException)   // passes
check(remainder.exceptionOrNull() is ArithmeticException)  // passes

Summary table:

Expression	JVM / Native	JavaScript
`12 / 0`	`ArithmeticException`	`0`
`12 % 0`	`ArithmeticException`	`0`

🤔 Why it happens

On Kotlin/JS, Int values are represented as JavaScript numbers, and 12 / 0 evaluates to Infinity while 12 % 0 evaluates to NaN. Kotlin/JS truncates Int arithmetic to 32 bits using JavaScript's | 0 operator, and per the ECMAScript ToInt32 conversion, both Infinity | 0 and NaN | 0 evaluate to 0 — so the division-by-zero result silently becomes 0, with no exception thrown.

JVM and Native follow Java's long-standing contract: integer division by zero is always an ArithmeticException.

The practical consequence is that any guard you write and test on JVM — a try/catch(ArithmeticException) or a pre-condition check that relies on an exception — is silently bypassed when the same code runs on JS. No compile error, no warning, just a wrong result.

✅ The fix: `Integer` from Kotools Types 5.1.1

The Integer type in Kotools Types explicitly checks for a zero divisor before delegating to the platform, so both div and rem throw ArithmeticException consistently on JVM, JavaScript, and Native.

@OptIn(ExperimentalKotoolsTypesApi::class)
fun main() {
    val a: Integer = Integer.from(12)
    val b: Integer = Integer.from(0)

    a / b   // ArithmeticException on JVM, JS, and Native
    a % b   // ArithmeticException on JVM, JS, and Native
}

If you prefer to avoid exception handling altogether, divOrNull and
remOrNull return null instead of throwing:

@OptIn(ExperimentalKotoolsTypesApi::class)
fun main() {
    val a: Integer = Integer.from(12)
    val b: Integer = Integer.from(0)

    val quotient: Integer? = a.divOrNull(b)   // null — no exception
    val remainder: Integer? = a.remOrNull(b)  // null — no exception
}

Integer is annotated with @ExperimentalKotoolsTypesApi and will be stabilized in a future release.

🛠️ Adding Kotools Types to your project

// build.gradle.kts
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("org.kotools.types:types:5.1.1")
        }
    }
}

Opt in either per call-site with @OptIn(ExperimentalKotoolsTypesApi::class) or project-wide via the compiler argument:

// build.gradle.kts
kotlin {
    compilerOptions {
        freeCompilerArgs.add("-opt-in=org.kotools.types.ExperimentalKotoolsTypesApi")
    }
}

💬 Discussion

Have you run into this inconsistency in a real project? How do you currently guard against division by zero in your multiplatform code?

DEV Community: Kotools

🚀 What's new in Kotools Types 5.2.0

🧮 Integer got a faster internal representation

🎯 Decimal arrives: exact arithmetic without floating-point

➗ Integer division is now Euclidean, and total

🔒 Sign as a type: NonZeroInteger, NonNegativeInteger, NonPositiveInteger

🛠️ Adding Kotools Types to your project

💬 Discussion

⚠️ The Kotlin Multiplatform division-by-zero trap

🐛 The problem

🤔 Why it happens

✅ The fix: Integer from Kotools Types 5.1.1

🛠️ Adding Kotools Types to your project

💬 Discussion

🧮 `Integer` got a faster internal representation

🎯 `Decimal` arrives: exact arithmetic without floating-point

➗ `Integer` division is now Euclidean, and total

🔒 Sign as a type: `NonZeroInteger`, `NonNegativeInteger`, `NonPositiveInteger`

✅ The fix: `Integer` from Kotools Types 5.1.1