Targetint(3) OCaml library Targetint(3)

# [NAME](#NAME)

Targetint - Target processor-native integers.

# [Module](#Module)

Module Targetint

# [Documentation](#Documentation)

Module **Targetint**  
: **sig end**

Target processor-native integers.

This module provides 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. All arithmetic operations over are taken modulo 2^32 or 2^64 depending on the word size of the target architecture.

Warning: this module is unstable and part of **Compiler\_libs** .

*type t*

The type of target integers.

*val zero* : **t**

The target integer 0.

*val one* : **t**

The target integer 1.

*val minus\_one* : **t**

The target integer -1.

*val neg* : **t -> t**

Unary negation.

*val add* : **t -> t -> t**

Addition.

*val sub* : **t -> t -> t**

Subtraction.

*val mul* : **t -> t -> t**

Multiplication.

*val div* : **t -> t -> t**

Integer division. Raise **Division\_by\_zero** if the second argument is zero. 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.

*val rem* : **t -> t -> t**

Integer remainder. If **y** is not zero, the result of **Targetint.rem x y** satisfies the following properties: **Targetint.zero <= Nativeint.rem x y < Targetint.abs y** and **x = Targetint.add (Targetint.mul (Targetint.div x y) y)**  
(Targetint.rem x y) . If **y = 0** , **Targetint.rem x y** raises **Division\_by\_zero** .

*val unsigned\_rem* : **t -> t -> t**

Same as **Targetint.rem** , except that arguments and result are interpreted as unsigned integers.

*val succ* : **t -> t**

Successor. **Targetint.succ x** is **Targetint.add x Targetint.one** .

*val pred* : **t -> t**

Predecessor. **Targetint.pred x** is **Targetint.sub x Targetint.one** .

*val abs* : **t -> t**

**abs x** is the absolute value of **x** . On **min\_int** this is **min\_int** itself and thus remains negative.

*val size* : **int**

The size in bits of a target native integer.

*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.

*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.

*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.

*val lognot* : **t -> t**

Bitwise logical negation.

*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.

*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** .

*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** .

*val of\_int* : **int -> t**

Convert the given integer (type **int** ) to a target integer (type **t** ), module 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.

*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.

*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** ].

*val to\_float* : **t -> float**

Convert the given target integer to a floating-point number.

*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.

*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** ).

*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. Raise **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** .

*val to\_string* : **t -> string**

Return the string representation of its argument, in decimal.

*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** .

*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.

*type repr* =  
| Int32 **of** **int32**  
| Int64 **of** **int64**

*val repr* : **t -> repr**

The concrete representation of a native integer.

*val print* : **Format.formatter -> t -> unit**

Print a target integer to a formatter.

2026-10-01 OCamldoc

---

Document: Targetint(3o) from ocaml 5.5.1-r1 (Chainguard OS)
Source: https://github.com/ocaml/ocaml