Basic Types

Kotlin never auto-converts a smaller number type to a bigger one. An Int is not a Long. You must convert it yourself by calling a conversion function, for example anInt.toLong().

Whole numbers: Byte, Short, Int, Long. Fractional: Float, Double. Write hex as 0xFF, binary as 0b1010, use underscores like 1_000 for readability, and add an L suffix (1L) to make a Long.

A triple-quoted string is wrapped in three quotes. It can span many lines and treats backslashes as plain text, so you don't need escape codes like \n or \.

String templates let you put values inside a string. Use $name to insert a variable, and ${...} to insert a whole expression. Kotlin replaces them with the text of the value.

A String is an immutable sequence of characters. You read a character with square brackets, like s[0]. You can't change a String in place; any 'change' creates a brand-new String and leaves the original untouched.

An unsuffixed integer literal is Int if it fits in 32 bits, otherwise Long. If every operand in a multiplication is Int, the math is done in Int and can overflow silently. Add an L to one operand to force Long math.

trimIndent() finds the common leading whitespace shared by all non-blank lines and removes that much from every line, so indented source code produces clean, left-aligned text.

Kotlin never converts numbers implicitly, so you call explicit functions like toUInt(), toInt(), toULong(), or toUByte(). Converting reinterprets the bits, which can flip a negative signed number into a large unsigned one.

Kotlin has four unsigned integer types: UByte, UShort, UInt, and ULong. They only hold zero and positive numbers. You write unsigned literals by adding the suffix u (or uL for ULong), like 42u or 0xFFu.

&& and || are short-circuit: they stop early once the result is known, so the right side may not run. and/or always evaluate both sides. Use && / || when the right side has a side effect or could crash if reached.

Math operators like + come in many versions, one per type combination. Int.plus(Long) returns a Long. So the operator itself handles the mix and gives the wider result — it's not the variable being auto-converted.

Narrowing keeps only the low bits and throws nothing. 300.toByte() is 44 because 300 doesn't fit in a byte, so the extra bits are dropped. Always check ranges before narrowing.

L makes a Long, f/F makes a Float. There is no Byte/Short suffix and no Int suffix. A small constant like 100 can be assigned to a Byte or Short variable directly because the compiler sees it fits the declared type.

trimMargin() removes everything up to and including a marker character (a pipe | by default) at the start of each line. You mark where each line should begin, giving explicit control.

Write ${'$'} to output a real dollar sign. In normal strings you can also use the escape $, but in triple-quoted strings backslashes are literal, so ${'$'} is the only way.

Kotlin runs the expression, then calls its toString() to get text. A null becomes the word "null". For your own classes, the result depends on the toString() you write (or the default one).

Each unsigned type is an inline value class that wraps the matching signed type. The JVM has no unsigned integers, so a UInt is really an Int at runtime, reinterpreted as unsigned. There's usually no boxing, so it's fast.

A Boolean? can be true, false, or null, so you can't use it directly in an if. Writing flag == true safely treats null as 'not true' (false). It's a common, null-safe way to check a nullable flag.

For a nullable number you call the conversion with a safe call: n?.toLong(). For a Char, you don't use toInt() anymore — you use the code property to get its numeric code, and Char(code) to go back.

In source you always write the class name Int. On the JVM the compiler uses the cheap primitive int where it can, but switches to the boxed java.lang.Integer when the value must be nullable (Int?) or used as a generic type argument, like in a List<Int>.

Regex and Windows paths contain many backslashes. In a normal string you must double each one, which is noisy and error-prone. Raw strings keep backslashes literal, so the pattern reads exactly as intended.

Templates run even in raw strings, so a bare $ before a name becomes a variable. Write a literal dollar with ${'$'}. Three quotes are hard to embed; use a template like ${"""""} to insert them.

The short form grabs the longest identifier after $, which can swallow characters you didn't mean. A $ followed by a space or symbol is literal. Braces let you nest other strings and expressions safely.

Templates just paste text, so don't use them to build SQL, HTML, or shell commands from user input — that's an injection risk. Also be careful logging sensitive data and that number formatting may not match a user's locale.

Unsigned arithmetic wraps around silently on overflow, never throwing. Division and comparison use unsigned rules, so big values aren't treated as negative. You cannot freely mix signed and unsigned in one expression; you must convert first.

Underscores are just visual separators between digits and don't change the value. They can't be at the start, the end, or right next to the 0x/0b prefix. Hex is 0x, binary is 0b, and there is no octal.

A Kotlin Char only holds 16 bits, but some characters (like many emoji) need more. Those are stored as two Chars (a 'surrogate pair'), so String.length counts them as 2 and a single index gives you only half a character.

Kotlin makes conversions explicit so number-type changes are visible and you don't get surprising silent ones. The cost is more .toLong() calls, but Kotlin softens that with smart literals and overloaded operators so normal code rarely suffers.

Use unsigned types when a value is naturally non-negative and may exceed the signed maximum, like bit masks or binary protocol fields. Avoid them in public APIs shared with Java, because interop and tooling get awkward; signed Int with masking is often safer there.