Hugs-Specific Libraries

Hugs-Specific Libraries

Number This library defines a numeric datatype of fixed width integers (whatever Int supplies). However, unlike the built-in Int type, overflows are detected and cause a run-time error. To ensure that all integer arithmetic in a given module includes overflow protection you must include a default declaration for Number (see Section 4.3.4 of the Report).
```
  module Number where
  data Number              -- fixed width integers
  instance Eq       Number -- class instances
  instance Ord      Number
  instance Show     Number
  instance Enum     Number
  instance Num      Number
  instance Bounded  Number
  instance Real     Number
  instance Ix       Number
  instance Integral Number
```
IOExtensions This module provides the following non-standard extensions to the IO monad.
- Binary file operations.
  These variants of the standard Prelude functions provide a portable way to read binary files without risking the dreaded CRLF to LF translation performed on DOS and similar systems.
- getCh is identical to getChar except that it doesn't echo to the screen.
- argv returns the same list of strings as getArgv. Though semantically sound, its use is considered controversial.
None of these operations can be implemented using standard Haskell libraries.
```
  module IOExtensions where
  readBinaryFile     :: FilePath -> IO String
  writeBinaryFile    :: FilePath -> String -> IO ()
  appendBinaryFile   :: FilePath -> String -> IO ()
  openBinaryFile     :: FilePath -> IOMode -> IO Handle
  getCh              :: IO Char
  argv               :: [String]
```

ListUtils This module includes list functions that were removed from the Prelude in the move from Haskell 1.2 to Haskell 1.3.

  module ListUtils where
  sums, products   :: Num a => [a] -> [a]
  subsequences     :: [a] -> [[a]]
  permutations     :: [a] -> [[a]]

ParseLib This module provides a library of parser combinators, as described in [3].
Sequence This module defines a new type constructor List which is isomorphic to the standard type constructor []. It also defines all the standard instance declarations which allows the use of list comprehensions, map, zero, return, ++, filter, etc. with type List. The essential difference between the two types is that List provides constant time append (++) whereas [] provides linear time append.
This module also defines a class Sequence for listlike type constructors which defines functions to convert from one listlike type to another. Instances for [], List and Maybe are defined.
```
  module Sequence
  data List a -- abstract
  instance Eq a => Eq (List a) 
  instance Ord a => Ord (List a) 
  instance Read a => Read (List a) 
  instance Show a => Show (List a) 
  instance Functor List 
  instance Monad List 
  instance MonadZero List 
  instance MonadPlus List 
  instance Sequence List 

  class (Functor m, MonadPlus m) => Sequence m where
    fromList :: [a] -> m a
    toList   :: m a -> [a]
  instance Sequence []
  instance Sequence List
  instance Sequence Maybe
```
Trace: This library provides a single function, that can sometimes be useful for debugging:
```
  module Trace where
  trace :: String -> a -> a
```
When called, trace prints the string in its first argument, and then returns the second argument as its result. The trace function is not referentially transparent, and should only be used for debugging, or for monitoring execution. You should also be warned that, unless you understand some of the details about the way that Hugs programs are executed, results obtained using trace can be rather confusing. For example, the messages may not appear in the order that you expect. Even ignoring the output that they produce, adding calls to trace can change the semantics of your program. Consider this a warning!

Interact: This library provides facilities for writing simple interactive programs.

  module Interact where
  type Interact = String -> String
  end                :: Interact
  readChar, peekChar :: Interact -> (Char -> Interact) -> Interact
  pressAnyKey        :: Interact -> Interact
  unreadChar         :: Char -> Interact -> Interact
  writeChar          :: Char -> Interact -> Interact
  writeStr           :: String -> Interact -> Interact
  ringBell           :: Interact -> Interact
  readLine           :: String -> (String -> Interact) -> Interact

An expression e of type Interact can be executed as a program by evaluating run e.

AnsiScreen This library defines some basic ANSI escape seqences for terminal control.

  module AnsiScreen where
  type Pos  = (Int,Int)
  at        :: Pos -> String -> String
  highlight :: String -> String
  goto      :: Int -> Int -> String
  home      :: String
  cls       :: String

The definitions in this module will need to be adapted to work with terminals that do not support ANSI escape sequences.

AnsiInteract This library includes both Interact and AnsiScreen, and also contains further support for screen oriented interactive I/O.

  module AnsiInteract(module AnsiInteract,
                      module Interact,
                      module AnsiScreen) where
  import AnsiScreen
  import Interact

  clearScreen       :: Interact -> Interact
  writeAt           :: Pos -> String -> Interact -> Interact
  moveTo            :: Pos -> Interact -> Interact
  readAt            :: Pos                  -> -- start coords
                       Int                  -> -- max input length
                       (String -> Interact) -> -- continuation
                       Interact
  defReadAt         :: Pos                  -> -- start coords
                       Int                  -> -- max input length
                       String               -> -- default value
                       (String -> Interact) -> -- continuation
                       Interact
  promptReadAt      :: Pos                  -> -- start coords
                       Int                  -> -- max input length     
                       String               -> -- prompt
                       (String -> Interact) -> -- continuation
                       Interact
  defPromptReadAt   :: Pos                  -> -- start coords
                       Int                  -> -- max input length     
                       String               -> -- prompt
                       String               -> -- default value
                       (String -> Interact) -> -- continuation
                       Interact

Win32 This library contains Haskell versions for many of the functions in the Microsoft Win32 library. It is only available on Windows 95/NT.
Graphics A comprehensive graphics and windowing library for Win32 is described separately. This is a higher level interface to much of the Win32 library.