Int package:Cabal-syntax
A fixed-precision integer type with at least the range
[-2^29 ..
2^29-1]. The exact range for a given implementation can be
determined by using
minBound and
maxBound from the
Bounded class.
16-bit signed integer type
32-bit signed integer type
64-bit signed integer type
8-bit signed integer type
Arbitrary precision integers. In contrast with fixed-size integral
types such as
Int, the
Integer type represents the
entire infinite range of integers.
Integers are stored in a kind of sign-magnitude form, hence do not
expect two's complement form when using bit operations.
If the value is small (fit into an
Int),
IS constructor
is used. Otherwise
Integer and
IN constructors are used
to store a
BigNat representing respectively the positive or the
negative value magnitude.
Invariant:
Integer and
IN are used iff value doesn't fit
in
IS
Integral numbers, supporting integer division.
The Haskell Report defines no laws for
Integral. However,
Integral instances are customarily expected to define a
Euclidean domain and have the following properties for the
div/
mod and
quot/
rem pairs, given suitable
Euclidean functions
f and
g:
- x = y * quot x y + rem x y with rem x y
= fromInteger 0 or g (rem x y) < g
y
- x = y * div x y + mod x y with mod x y
= fromInteger 0 or f (mod x y) < f
y
An example of a suitable Euclidean function, for
Integer's
instance, is
abs.
In addition,
toInteger should be total, and
fromInteger
should be a left inverse for it, i.e.
fromInteger (toInteger i) =
i.
Intel, Intel Open Source License
Intel-ACPI, Intel ACPI Software License Agreement
Interbase-1.0, Interbase Public License v1.0
Enable interruptible FFI.
The
interact function takes a function of type
String->String as its argument. The entire input from the
standard input device is passed to this function as its argument, and
the resulting string is output on the standard output device.
intercalate xs xss is equivalent to
(concat
(intersperse xs xss)). It inserts the list
xs in
between the lists in
xss and concatenates the result.
>>> intercalate ", " ["Lorem", "ipsum", "dolor"]
"Lorem, ipsum, dolor"
The
intersperse function takes an element and a
list and `intersperses' that element between the elements of the list.
For example,
>>> intersperse ',' "abcde"
"a,b,c,d,e"
The intersection <math> of two interval sequences <math>
and <math> of lengths <math> and <math>, resp.,
satisfies the specification <math>. Thanks to the ordered
representation of intervals it can be computed in <math> (rather
than the naive <math>.
The length of <math> is <math>.
The version range
vr1 && vr2.
withinRange v' (intersectVersionRanges vr1 vr2)
= withinRange v' vr1 && withinRange v' vr2
Interpret a symbolic path with respect to the given directory.
Use this function before directly interacting with the file system in
order to take into account a working directory argument.
NB: when invoking external programs (such as
GHC), it is
preferable to set the working directory of the process and use
interpretSymbolicPathCWD rather than calling this function, as
this function will turn relative paths into absolute paths if the
working directory is an absolute path. This can degrade error
messages, or worse, break the behaviour entirely (because the program
might expect certain paths to be relative).
See Note [Symbolic paths] in Distribution.Utils.Path.
Interpret a symbolic path, **under the assumption that the working
directory is the package directory**.
Use
interpretSymbolicPath instead if you need to take into
account a working directory argument before directly interacting with
the file system.
Use this function instead of
interpretSymbolicPath when
invoking a child process: set the working directory of the
sub-process, and use this function, e.g.:
callGhc :: Maybe (SymbolicPath CWD (Dir Pkg))
-> SymbolicPath (Dir Pkg) File
-> IO ()
callGhc mbWorkDir inputFile =
runProgramInvocation $
programInvocationCwd mbWorkDir ghcProg [interpretSymbolicPathCWD inputFile]
In this example,
programInvocationCwd sets the working
directory, so it is appropriate to use
interpretSymbolicPathCWD
to provide its arguments.
See Note [Symbolic paths] in Distribution.Utils.Path.
Accepts negative (starting with -) and positive (without
sign) integral numbers.