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

&&.

The only purpose of this module is to prevent the export of VersionRange constructors from Distribution.Types.VersionRange. To avoid creating orphan instances, a lot of related code had to be moved here too.

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"

Interpret a ModuleRenaming as a partial map from ModuleName to ModuleName. For efficiency, you should partially apply it with ModuleRenaming and then reuse it.

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.