This file is indexed.

/usr/lib/hugs/oldlib/Number.hs is in hugs 98.200609.21-5.3ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
-----------------------------------------------------------------------------
-- Number.hs:	Fixed width integers with overflow detection
--
-- This library defines a numeric datatype of fixed width integers
-- (whatever Int supplies).  But, unlike Int, overflows are detected and
-- cause a run-time error.  Covers all classes upto and including Bounded
-- and Ix.  A fairly messy hack, but it works (most of the time :-) ...
--
-- Suitable for use with Hugs 98
-----------------------------------------------------------------------------

module Number( 
	Number,
	-- instance Eq       Number,
	-- instance Ord      Number,
	-- instance Show     Number,
	-- instance Enum     Number,
	-- instance Num      Number,
	-- instance Bounded  Number,
	-- instance Real     Number,
	-- instance Ix       Number,
	-- instance Integral Number,
	) where

import Ix(Ix(..))

default (Number,Int,Float)

type Number = Int
  in numEq           :: Number -> Number -> Bool,
     numCmp          :: Number -> Number -> Ordering,
     numShowsPrec    :: Int -> Number -> ShowS,
     numEnumFrom     :: Number -> [Number],
     numEnumFromThen :: Number -> Number -> [Number],
     numAdd          :: Number -> Number -> Number,
     numSub          :: Number -> Number -> Number,
     numMul          :: Number -> Number -> Number,
     numNeg          :: Number -> Number,
     numFromInt      :: Int -> Number,
     numToInt        :: Number -> Int,
     numFromInteger  :: Integer -> Number,
     numToInteger    :: Number -> Integer,
     numMax          :: Number,
     numMin          :: Number,
     numSignum       :: Number -> Number,
     numToRat        :: Number -> Rational,
     numQrm          :: Number -> Number -> (Number, Number),
     numRange        :: (Number, Number) -> [Number],
     numIndex        :: (Number, Number) -> Number -> Int,
     numInRange      :: (Number, Number) -> Number -> Bool

numEq           = (==)
numCmp          = compare
numShowsPrec    = showsPrec
numEnumFrom     = enumFrom
numEnumFromThen = enumFromThen
numFromInt x    = x
numToInt x      = x
numFromInteger  = fromInteger
numToInteger    = toInteger
numMax          = maxBound
numMin          = minBound
numSignum       = signum
numToRat        = toRational
numQrm          = quotRem
numRange        = range
numIndex        = index
numInRange      = inRange

numAdd x y = if xsgn/=ysgn || xsgn==rsgn then r else error "add overflow!"
             where xsgn = x>=0
                   ysgn = y>=0
                   rsgn = r>=0
                   r    = x + y

numSub x y = if xsgn==ysgn || ysgn/=rsgn then r else error "sub overflow!"
             where xsgn = x>=0
                   ysgn = y>=0
                   rsgn = r>=0
                   r    = x - y

numMul x y = if y==0 || (r `div` y == x) then r else error "mult overflow!"
             where r = x * y

numNeg x   = if x>=0 || r>=0 then r else error "negate overflow!"
             where r = negate x

instance Eq Number where
  (==)   = numEq

instance Ord Number where
  compare = numCmp

instance Show Number where
  showsPrec = numShowsPrec

instance Enum Number where
  toEnum       = numFromInt
  fromEnum     = numToInt
  enumFrom     = numEnumFrom
  enumFromThen = numEnumFromThen

instance Num Number where
  (+)         = numAdd
  (-)         = numSub
  (*)         = numMul
  negate      = numNeg
  fromInt     = numFromInt
  fromInteger = numFromInteger
  abs x       = if x<0 then negate x else x
  signum      = numSignum

instance Bounded Number where
  minBound    = numMin
  maxBound    = numMax

instance Real Number where
  toRational  = numToRat

instance Ix Number where
  range   = numRange
  index   = numIndex
  inRange = numInRange

instance Integral Number where
  quotRem   = numQrm
  toInteger = numToInteger

-----------------------------------------------------------------------------