Targetint(3)

🎀 Targetint 💅 OCaml library — section 3 of the manual, bestie 🫶

okay so picture this: you're in the Targetint(3) page of the OCaml library docs and it's literally all about target processor-native integers. like, the ints that actually match the machine you're compiling for, not the one you're sitting at. iconic behaviour honestly ✨

---

✨ NAME ✨

Targetint — target processor-native integers, and yes that's the whole vibe 💫

---

🦋 Module 🦋

Module Targetint

Module Targetint
 : sig end

Target processor-native integers.

So here's the tea 🍓 this module gives you operations on the type of signed 32-bit integers (on 32-bit target platforms) or signed 64-bit integers (on 64-bit target platforms). this integer type has exactly the same width as that of a pointer type in the C compiler — same width, no cap.

and every arithmetic operation over them is taken modulo 2^32 or 2^64 depending on the word size of the target architecture. so it wraps, it doesn't cry, it just wraps 💅

⚠️ Warning: this module is unstable and part of Compiler_libs. ngl, unstable means unstable — don't build your whole personality on it 🙈

---

🌸 Documentation 🌸

🧚 the types & values, one by one

• type t — The type of target integers. that's her. the main character 👑
• val zero : t — The target integer 0. the beginning of everything 🎀
• val one : t — The target integer 1. her bestie.
• val minus_one : t — The target integer -1. the edgy one 💀
• val neg : t -> t — Unary negation. flip the sign, flip the vibe.
• val add : t -> t -> t — Addition. math slay.
• val sub : t -> t -> t — Subtraction. taking things away, respectfully.
• val mul : t -> t -> t — Multiplication. the girlies are multiplying 🔥
• val div : t -> t -> t — Integer division. raises Division_by_zero if the second argument is zero — so like, don't 👀. this division rounds the real quotient of its arguments towards zero, as specified for (/).
• val unsigned_div : t -> t -> t — Same as Targetint.div, except that arguments and result are interpreted as unsigned integers. no negativity allowed ✨
• val rem : t -> t -> t — Integer remainder. if y is not zero, the result of Targetint.rem x y satisfies these properties:
  • Targetint.zero <= Nativeint.rem x y < Targetint.abs y
  • x = Targetint.add (Targetint.mul (Targetint.div x y) y) (Targetint.rem x y)

if y = 0, then Targetint.rem x y raises Division_by_zero. zero is not invited to this party 🚫

• val unsigned_rem : t -> t -> t — Same as Targetint.rem, except that arguments and result are interpreted as unsigned integers. again: only good vibes, no signs 💜
• val succ : t -> t — Successor. Targetint.succ x is Targetint.add x Targetint.one. one step forward, periodt.
• val pred : t -> t — Predecessor. Targetint.pred x is Targetint.sub x Targetint.one. one step back, still slaying.
• val abs : t -> t — abs x is the absolute value of x. BUT — and this is the plot twist 😭 — on min_int this is min_int itself and thus remains negative. the one case where the glow-up doesn't happen.
• val size : int — The size in bits of a target native integer. lowkey the most important number here.
• val max_int : t — The greatest representable target integer, either 2^31 - 1 on a 32-bit platform, or 2^63 - 1 on a 64-bit platform. the ceiling, literally.
• val min_int : t — The smallest representable target integer, either -2^31 on a 32-bit platform, or -2^63 on a 64-bit platform. the floor. she's doing her best.
• val logand : t -> t -> t — Bitwise logical and.
• val logor : t -> t -> t — Bitwise logical or.
• val logxor : t -> t -> t — Bitwise logical exclusive or. spicy.
• val lognot : t -> t — Bitwise logical negation. flipping every single bit, no thoughts 💅
• val shift_left : t -> int -> t — Targetint.shift_left x y shifts x to the left by y bits. the result is unspecified if y < 0 or y >= bitsize, where bitsize is 32 on a 32-bit platform and 64 on a 64-bit platform. unspecified means don't ask, you won't like the answer 💀
• val shift_right : t -> int -> t — Targetint.shift_right x y shifts x to the right by y bits. this is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. the result is unspecified if y < 0 or y >= bitsize. same warning, same energy 🙈
• val shift_right_logical : t -> int -> t — Targetint.shift_right_logical x y shifts x to the right by y bits. this is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. the result is unspecified if y < 0 or y >= bitsize. zeroes only, she doesn't care about your sign 🧚
• val of_int : int -> t — Convert the given integer (type int) to a target integer (type t), modulo the target word size. 🫶
• val of_int_exn : int -> t — Convert the given integer (type int) to a target integer (type t). raises a fatal error if the conversion is not exact. no silent lies here, she will tell on you 🔥
• val to_int : t -> int — Convert the given target integer (type t) to an integer (type int). the high-order bit is lost during the conversion. gone. adiós. 😭
• val of_float : float -> t — Convert the given floating-point number to a target integer, discarding the fractional part (truncate towards 0). the result of the conversion is undefined if, after truncation, the number is outside the range [ Targetint.min_int , Targetint.max_int ]. undefined is not a cute look, check your range first bestie.
• val to_float : t -> float — Convert the given target integer to a floating-point number. glow-up into float ✨
• val of_int32 : int32 -> t — Convert the given 32-bit integer (type int32) to a target integer.
• val to_int32 : t -> int32 — Convert the given target integer to a 32-bit integer (type int32). on 64-bit platforms, the 64-bit native integer is taken modulo 2^32, i.e. the top 32 bits are lost 💀. on 32-bit platforms, the conversion is exact. platform-dependent behaviour, iykyk.
• val of_int64 : int64 -> t — Convert the given 64-bit integer (type int64) to a target integer.
• val to_int64 : t -> int64 — Convert the given target integer to a 64-bit integer (type int64). big girl conversion.
• val of_string : string -> t — Convert the given string to a target integer. the string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively. raises Failure "int_of_string" if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type nativeint. so yeah, bad input = Failure, no mercy 🙅
• val to_string : t -> string — Return the string representation of its argument, in decimal. always decimal, always straightforward.
• val compare : t -> t -> int — The comparison function for target integers, with the same specification as compare. along with the type t, this function compare allows the module Targetint to be passed as argument to the functors Set.Make and Map.Make. so she fits right into your data structures, bestie 🌈
• val unsigned_compare : t -> t -> int — Same as Targetint.compare, except that arguments are interpreted as unsigned integers.
• val equal : t -> t -> bool — The equal function for target ints. are they the same? true or false, that's it 💖

---

👑 the representation girlies

type repr =
 | Int32 of int32
 | Int64 of int64

• val repr : t -> repr — The concrete representation of a native integer. what's actually under the hood, no mystery ⭐
• val print : Format.formatter -> t -> unit — Print a target integer to a formatter. show her off 🌸

---

💡 quick vibe check recap: everything arithmetic wraps modulo 2^32 or 2^64 based on your target's word size, div/rem raise Division_by_zero on a zero divisor, the shifts are unspecified outside 0 <= y < bitsize, and the module is unstable and part of Compiler_libs. that's the whole story, fr fr.

---

and that's the page!! 🦋 this gorgeous little document was brought to you by OCamldoc, dated 2026-06-22, serving Targetint(3) realness. mwah 💋✨