foundation-0.0.17: Alternative prelude with batteries and no dependencies

License | BSD-style
Maintainer | foundation
Stability | experimental
Portability | portable
Safe Haskell | None
Language | Haskell2010

Foundation.System.Info

Contents

- Operation System info
- CPU info
- Compiler info

Description

Synopsis

- data OS
  - = Windows
  - | OSX
  - | Linux
  - | Android
  - | BSD
- os :: Either [Char] OS
- data Arch
  - = I386
  - | X86_64
  - | PowerPC
  - | PowerPC64
  - | Sparc
  - | Sparc64
  - | ARM
  - | ARM64
- arch :: Either [Char] Arch
- cpus :: IO Int
- data Endianness :: *
  - = LittleEndian
  - | BigEndian
- endianness :: Endianness
- compilerName :: String
- compilerVersion :: Version
- data Version :: * = Version {
  - versionBranch :: [Int]
  - versionTags :: [String]
  }

# Operation System info

data OS Source #

Constructors

Windows |
OSX |
Linux |
Android |
BSD |

Instances

Bounded OS Source # |
Methods minBound :: OS # maxBound :: OS #
Enum OS Source # |
Methods succ :: OS -> OS # pred :: OS -> OS # toEnum :: Int -> OS # fromEnum :: OS -> Int # enumFrom :: OS -> [OS] # enumFromThen :: OS -> OS -> [OS] # enumFromTo :: OS -> OS -> [OS] # enumFromThenTo :: OS -> OS -> OS -> [OS] #
Eq OS Source # |
Methods (==) :: OS -> OS -> Bool # (/=) :: OS -> OS -> Bool #
Data OS Source # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OS -> c OS #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OS #

toConstr :: OS -> Constr #

dataTypeOf :: OS -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OS) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OS) #

gmapT :: (forall b. Data b => b -> b) -> OS -> OS #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r #

gmapQ :: (forall d. Data d => d -> u) -> OS -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OS -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OS -> m OS #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OS -> m OS #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OS -> m OS #

Ord OS Source # |
Methods compare :: OS -> OS -> Ordering # (<) :: OS -> OS -> Bool # (<=) :: OS -> OS -> Bool # (>) :: OS -> OS -> Bool # (>=) :: OS -> OS -> Bool # max :: OS -> OS -> OS # min :: OS -> OS -> OS #
Show OS Source # |
Methods showsPrec :: Int -> OS -> ShowS # show :: OS -> String # showList :: [OS] -> ShowS #

os :: Either [Char] OS Source #

get the operating system on which the program is running.

Either return the known `OS` or a strict `String` of the OS name.

This function uses the `base`'s `os` function.

# CPU info

data Arch Source #

Enumeration of the known GHC supported architecture.

Constructors

I386 |
X86_64 |
PowerPC |
PowerPC64 |
Sparc |
Sparc64 |
ARM |
ARM64 |

Instances

Bounded Arch Source # |
Methods minBound :: Arch # maxBound :: Arch #
Enum Arch Source # |
Methods succ :: Arch -> Arch # pred :: Arch -> Arch # toEnum :: Int -> Arch # fromEnum :: Arch -> Int # enumFrom :: Arch -> [Arch] # enumFromThen :: Arch -> Arch -> [Arch] # enumFromTo :: Arch -> Arch -> [Arch] # enumFromThenTo :: Arch -> Arch -> Arch -> [Arch] #
Eq Arch Source # |
Methods (==) :: Arch -> Arch -> Bool # (/=) :: Arch -> Arch -> Bool #
Data Arch Source # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Arch -> c Arch #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Arch #

toConstr :: Arch -> Constr #

dataTypeOf :: Arch -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Arch) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arch) #

gmapT :: (forall b. Data b => b -> b) -> Arch -> Arch #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r #

gmapQ :: (forall d. Data d => d -> u) -> Arch -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Arch -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arch -> m Arch #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arch -> m Arch #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arch -> m Arch #

Ord Arch Source # |
Methods compare :: Arch -> Arch -> Ordering # (<) :: Arch -> Arch -> Bool # (<=) :: Arch -> Arch -> Bool # (>) :: Arch -> Arch -> Bool # (>=) :: Arch -> Arch -> Bool # max :: Arch -> Arch -> Arch # min :: Arch -> Arch -> Arch #
Show Arch Source # |
Methods showsPrec :: Int -> Arch -> ShowS # show :: Arch -> String # showList :: [Arch] -> ShowS #

arch :: Either [Char] Arch Source #

get the machine architecture on which the program is running

Either return the known architecture or a Strict `String` of the architecture name.

This function uses the `base`'s `arch` function.

cpus :: IO Int Source #

returns the number of CPUs the machine has

data Endianness :: * #

Constructors

LittleEndian |
BigEndian |

Instances

Eq Endianness |
Methods (==) :: Endianness -> Endianness -> Bool # (/=) :: Endianness -> Endianness -> Bool #
Show Endianness |
Methods showsPrec :: Int -> Endianness -> ShowS # show :: Endianness -> String # showList :: [Endianness] -> ShowS #

endianness :: Endianness #

endianness of the current architecture

# Compiler info

compilerName :: String Source #

get the compiler name

get the compilerName from base package but convert it into a strict String

compilerVersion :: Version #

The version of `compilerName` with which the program was compiled or is being interpreted.

data Version :: * #

A `Version` represents the version of a software entity.

An instance of `Eq` is provided, which implements exact equality modulo reordering of the tags in the `versionTags` field.

An instance of `Ord` is also provided, which gives lexicographic ordering on the `versionBranch` fields (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.). This is expected to be sufficient for many uses, but note that you may need to use a more specific ordering for your versioning scheme. For example, some versioning schemes may include pre-releases which have tags `"pre1"`, `"pre2"`, and so on, and these would need to be taken into account when determining ordering. In some cases, date ordering may be more appropriate, so the application would have to look for `date` tags in the `versionTags` field and compare those. The bottom line is, don't always assume that `compare` and other `Ord` operations are the right thing for every `Version`.

Similarly, concrete representations of versions may differ. One possible concrete representation is provided (see `showVersion` and `parseVersion`), but depending on the application a different concrete representation may be more appropriate.

Constructors

Version |

Fields

- versionBranch :: [Int]

  The numeric branch for this version. This reflects the fact that most software versions are tree-structured; there is a main trunk which is tagged with versions at various points (1,2,3...), and the first branch off the trunk after version 3 is 3.1, the second branch off the trunk after version 3 is 3.2, and so on. The tree can be branched arbitrarily, just by adding more digits.

  We represent the branch as a list of `Int`, so version 3.2.1 becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of `Ord` for `[Int]`) gives the natural ordering of branches.

- versionTags :: [String]

  A version can be tagged with an arbitrary list of strings. The interpretation of the list of tags is entirely dependent on the entity that this version applies to.

Instances

IsList Version | Since: 4.8.0.0
Associated Types type Item Version :: * # Methods fromList :: [Item Version] -> Version # fromListN :: Int -> [Item Version] -> Version # toList :: Version -> [Item Version] #
Eq Version |
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Data Version |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version #

toConstr :: Version -> Constr #

dataTypeOf :: Version -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Version) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) #

gmapT :: (forall b. Data b => b -> b) -> Version -> Version #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r #

gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #

Ord Version |
Methods compare :: Version -> Version -> Ordering # (<) :: Version -> Version -> Bool # (<=) :: Version -> Version -> Bool # (>) :: Version -> Version -> Bool # (>=) :: Version -> Version -> Bool # max :: Version -> Version -> Version # min :: Version -> Version -> Version #
Read Version |
Methods readsPrec :: Int -> ReadS Version # readList :: ReadS [Version] # readPrec :: ReadPrec Version # readListPrec :: ReadPrec [Version] #
Show Version |
Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Generic Version |
Associated Types type Rep Version :: * -> * # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
type Rep Version |
type Rep Version = D1 (MetaData "Version" "Data.Version" "base" False) (C1 (MetaCons "Version" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "versionBranch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Int])) (S1 (MetaSel (Just Symbol "versionTags") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [String]))))
type Item Version |
type Item Version = Int