On this page:
_  int8
_  sint8
_  uint8
_  int16
_  sint16
_  uint16
_  int32
_  sint32
_  uint32
_  int64
_  sint64
_  uint64
_  byte
_  sbyte
_  ubyte
_  wchar
_  word
_  sword
_  uword
_  short
_  sshort
_  ushort
_  int
_  sint
_  uint
_  long
_  slong
_  ulong
_  llong
_  sllong
_  ullong
_  intptr
_  sintptr
_  uintptr
_  size
_  ssize
_  ptrdiff
_  intmax
_  uintmax
_  fixnum
_  ufixnum
_  fixint
_  ufixint
_  float
_  double
_  double*
_  longdouble

3.2 Numeric Types 🔗

The basic integer types at various sizes. The s or u prefix specifies a signed or an unsigned integer, respectively; the ones with no prefix are signed.

The _sbyte and _ubyte types are aliases for _sint8 and _uint8, respectively. The _byte type is like _ubyte, but adds 256 to a negative Racket value that would work as a _sbyte (i.e., it casts signed bytes to unsigned bytes).

value

_wchar : ctype?

The _wchar type is an alias for an unsigned integer type, such as _uint16 or _uint32, corresponding to the platform’s wchar_t type.

Added in version 7.0.0.3 of package base.

The _sword and _uword types are aliases for _sint16 and _uint16, respectively. The _word type is like _uword, but coerces negative values in the same way as _byte.

Aliases for basic integer types. The _short aliases correspond to _int16. The _int aliases correspond to _int32. The _long aliases correspond to either _int32 or _int64, depending on the platform. Similarly, the _intptr aliases correspond to either _int32 or _int64, depending on the platform.

More aliases for basic integer types. The _size and _uintmax types are aliases for _uintptr, and the rest are aliases for _intptr.

For cases where speed matters and where you know that the integer is small enough, the types _fixnum and _ufixnum are similar to _intptr and _uintptr but assume that the quantities fit in Racket’s immediate integers (i.e., not bignums).

Similar to _fixnum/_ufixnum, but based on _int/_uint instead of _intptr/_uintptr, and coercions from C are checked to be in range.

The _float and _double types represent the corresponding C types. Both single- and double-precision Racket numbers are accepted for conversion via both _float and _double, while both _float and _double coerce C values to double-precision Racket numbers. The type _double* coerces any Racket real number to a C double.

Represents the long double type on platforms where it is supported, in which case Racket extflonums convert to and from long double values.