* `$`
* `$!`
* `$!!`
* `$>`
* `%`
* `&`
* `&&`
* `*`
* `**`
* `*>`
* `+`
* `++`
* `-`
* `.`
* `.&.`
* `.|.`
* `/`
* `/=`
* `:%`
* `:*:`
* `:+`
* `:+:`
* `:~:`
* `<`
* `<$`
* `<$!>`
* `<$>`
* `<*`
* `<**>`
* `<*>`
* `<.>`
* `<=`
* `<=<`
* `<>`
* `<|>`
* `=<<`
* `==`
* `==`
* `>`
* `>=`
* `>=>`
* `>>`
* `>>=`
* `All`
* `AllocationLimitExceeded`
* `Alt`
* `Alternative`
* `Any`
* `Any`
* `AppendMode`
* `Applicative`
* `ArithException`
* `ArrayException`
* `AssertionFailed`
* `AssertionFailed`
* `Async`
* `AsyncException`
* `Bifunctor`
* `Bits`
* `BlockedIndefinitelyOnMVar`
* `BlockedIndefinitelyOnMVar`
* `BlockedIndefinitelyOnSTM`
* `BlockedIndefinitelyOnSTM`
* `Bool`
* `Bool`
* `Bounded`
* `ByteString`
* `C1`
* `Chan`
* `Char`
* `Coercible`
* `Coercion`
* `Coercion`
* `Complex`
* `Concurrently`
* `Concurrently`
* `Const`
* `Const`
* `Constraint`
* `Constructor`
* `D#`
* `D1`
* `Deadlock`
* `Deadlock`
* `Denormal`
* `DivideByZero`
* `Double`
* `Double#`
* `Down`
* `Down`
* `Dual`
* `Dual`
* `EQ`
* `Either`
* `Endo`
* `Endo`
* `Enum`
* `Eq`
* `ErrorCall`
* `ErrorCall`
* `Except`
* `ExceptT`
* `Exception`
* `ExitCode`
* `ExitFailure`
* `ExitSuccess`
* `F#`
* `FFExponent`
* `FFFixed`
* `FFFormat`
* `FFGeneric`
* `False`
* `FatalError`
* `FatalError`
* `FilePath`
* `FiniteBits`
* `First`
* `First`
* `Fixity`
* `Float`
* `Float#`
* `Floating`
* `Foldable`
* `Fractional`
* `FunPtr`
* `Functor`
* `GT`
* `Generic`
* `Handle`
* `Handler`
* `Handler`
* `HeapOverflow`
* `IO`
* `IOException`
* `IOMode`
* `Identity`
* `Identity`
* `IndexOutOfBounds`
* `Infix`
* `Int`
* `Int`
* `Int16`
* `Int32`
* `Int64`
* `Int8`
* `IntMap`
* `IntSet`
* `Integer`
* `Integral`
* `IsString`
* `Just`
* `K1`
* `K1`
* `LByteString`
* `LT`
* `LText`
* `Last`
* `Last`
* `Left`
* `Leniency`
* `Lenient`
* `LossOfPrecision`
* `M1`
* `M1`
* `MVar`
* `Map`
* `MaskedInterruptible`
* `MaskedUninterruptible`
* `MaskingState`
* `Maybe`
* `Monad`
* `MonadError`
* `MonadIO`
* `MonadPlus`
* `MonadReader`
* `MonadState`
* `Monoid`
* `NFData`
* `NestedAtomically`
* `NestedAtomically`
* `NoMethodError`
* `NoMethodError`
* `NonTermination`
* `NonTermination`
* `Nothing`
* `Num`
* `Ord`
* `Ordering`
* `Ordering`
* `Overflow`
* `PatternMatchFail`
* `PatternMatchFail`
* `Prefix`
* `Print`
* `Product`
* `Product`
* `Proxy`
* `Proxy`
* `Ptr`
* `QSem`
* `QSemN`
* `Ratio`
* `RatioZeroDenominator`
* `Rational`
* `Read`
* `ReadMode`
* `ReadWriteMode`
* `Reader`
* `ReaderT`
* `Real`
* `RealFloat`
* `RealFrac`
* `RealWorld`
* `Rec0`
* `RecConError`
* `RecConError`
* `RecSelError`
* `RecSelError`
* `RecUpdError`
* `RecUpdError`
* `Refl`
* `Rep`
* `Rep`
* `Right`
* `S1`
* `ST`
* `STM`
* `Selector`
* `Semiring`
* `Seq`
* `Set`
* `Show`
* `SomeAsyncException`
* `SomeAsyncException`
* `SomeException`
* `SomeException`
* `StackOverflow`
* `State`
* `StateT`
* `Storable`
* `Strict`
* `StringConv`
* `Sum`
* `Sum`
* `Text`
* `ThreadId`
* `ThreadKilled`
* `Traversable`
* `True`
* `TypeRep`
* `Typeable`
* `U1`
* `U1`
* `UndefinedElement`
* `Underflow`
* `Unmasked`
* `UserInterrupt`
* `V1`
* `Void`
* `Word`
* `Word`
* `Word16`
* `Word32`
* `Word64`
* `Word8`
* `WriteMode`
* `ZipList`
* `ZipList`
* `^`
* `^%^`
* `^^`
* `^^%^^`
* `abs`
* `absInteger`
* `absurd`
* `acos`
* `acosDouble`
* `acosFloat`
* `acosh`
* `addMVarFinalizer`
* `all`
* `allowInterrupt`
* `always`
* `alwaysSucceeds`
* `and`
* `andInteger`
* `any`
* `ap`
* `appEndo`
* `appendFile`
* `applyN`
* `asTypeOf`
* `asin`
* `asinDouble`
* `asinFloat`
* `asinh`
* `ask`
* `asks`
* `asum`
* `async`
* `asyncBound`
* `asyncExceptionFromException`
* `asyncExceptionToException`
* `asyncOn`
* `asyncOnWithUnmask`
* `asyncThreadId`
* `asyncWithUnmask`
* `atDef`
* `atMay`
* `atan`
* `atan2`
* `atanDouble`
* `atanFloat`
* `atanh`
* `atomically`
* `bimap`
* `bit`
* `bitDefault`
* `bitSize`
* `bitSizeMaybe`
* `bool`
* `boundedEnumFrom`
* `boundedEnumFromThen`
* `bracket`
* `bracketOnError`
* `bracket_`
* `break`
* `byteSwap16`
* `byteSwap32`
* `byteSwap64`
* `cancel`
* `cancelWith`
* `cast`
* `castWith`
* `catMaybes`
* `catch`
* `catchError`
* `catchJust`
* `catchSTM`
* `catches`
* `ceiling`
* `check`
* `chr`
* `cis`
* `clamp`
* `clearBit`
* `coerceWith`
* `compare`
* `compareInteger`
* `comparing`
* `complement`
* `complementBit`
* `complementInteger`
* `conFixity`
* `conIsRecord`
* `conName`
* `concat`
* `concatMap`
* `concatMapM`
* `concurrently`
* `conjugate`
* `const`
* `cos`
* `cosDouble`
* `cosFloat`
* `cosh`
* `coshDouble`
* `coshFloat`
* `countLeadingZeros`
* `countTrailingZeros`
* `curry`
* `cycle`
* `decodeDoubleInteger`
* `decodeFloat`
* `decodeUtf8`
* `decodeUtf8'`
* `decodeUtf8With`
* `deepseq`
* `denominator`
* `die`
* `div`
* `divInteger`
* `divMod`
* `divModInteger`
* `divZeroError`
* `divideDouble`
* `divideFloat`
* `double2Float`
* `double2Int`
* `doubleFromInteger`
* `drop`
* `dropWhile`
* `dupChan`
* `either`
* `eitherA`
* `elem`
* `empty`
* `encodeDoubleInteger`
* `encodeFloat`
* `encodeFloatInteger`
* `encodeUtf8`
* `enumFrom`
* `enumFromThen`
* `enumFromThenTo`
* `enumFromTo`
* `eqDouble`
* `eqFloat`
* `eqInteger`
* `eqInteger#`
* `eqT`
* `evalState`
* `evalStateT`
* `evaluate`
* `even`
* `execState`
* `execStateT`
* `exitFailure`
* `exitSuccess`
* `exitWith`
* `exp`
* `expDouble`
* `expFloat`
* `exponent`
* `expt`
* `expts`
* `expts10`
* `fatalErrorMessage`
* `filter`
* `filterM`
* `finally`
* `find`
* `finiteBitSize`
* `first`
* `fix`
* `fixST`
* `flip`
* `float2Double`
* `float2Int`
* `floatDigits`
* `floatFromInteger`
* `floatRadix`
* `floatRange`
* `floatToDigits`
* `floor`
* `fmap`
* `fmapDefault`
* `fold`
* `foldM`
* `foldM_`
* `foldMap`
* `foldMapDefault`
* `foldl`
* `foldl'`
* `foldl1May`
* `foldlM`
* `foldr`
* `foldr'`
* `foldr1May`
* `foldrM`
* `for`
* `forConcurrently`
* `forM`
* `forM_`
* `for_`
* `force`
* `forever`
* `forkFinally`
* `forkIO`
* `forkIOWithUnmask`
* `forkOS`
* `forkOn`
* `forkOnWithUnmask`
* `formatRealFloat`
* `formatRealFloatAlt`
* `from`
* `fromEnum`
* `fromEnumError`
* `fromException`
* `fromInteger`
* `fromIntegral`
* `fromMaybe`
* `fromRat`
* `fromRat'`
* `fromRat''`
* `fromRational`
* `fromStrict`
* `fst`
* `gcastWith`
* `gcd`
* `gcdInt'`
* `gcdWord'`
* `geDouble`
* `geFloat`
* `geInteger`
* `geInteger#`
* `get`
* `getAll`
* `getAlt`
* `getAny`
* `getArgs`
* `getChanContents`
* `getConst`
* `getContents`
* `getDual`
* `getFirst`
* `getLast`
* `getLine`
* `getMaskingState`
* `getNumCapabilities`
* `getProduct`
* `getSum`
* `getZipList`
* `gets`
* `group`
* `gtDouble`
* `gtFloat`
* `gtInteger`
* `gtInteger#`
* `guard`
* `guardM`
* `handle`
* `handleJust`
* `hashInteger`
* `head`
* `headDef`
* `headMay`
* `hPutStr`
* `hPutStrLn`
* `identity`
* `ifM`
* `imagPart`
* `infinity`
* `initDef`
* `initMay`
* `initSafe`
* `inits`
* `int2Double`
* `int2Float`
* `integerLogBase`
* `integerToInt`
* `integerToWord`
* `integralEnumFrom`
* `integralEnumFromThen`
* `integralEnumFromThenTo`
* `integralEnumFromTo`
* `interact`
* `intercalate`
* `intersperse`
* `ioError`
* `isCurrentThreadBound`
* `isDenormalized`
* `isDoubleDenormalized`
* `isDoubleFinite`
* `isDoubleInfinite`
* `isDoubleNaN`
* `isDoubleNegativeZero`
* `isEmptyChan`
* `isEmptyMVar`
* `isFloatDenormalized`
* `isFloatFinite`
* `isFloatInfinite`
* `isFloatNaN`
* `isFloatNegativeZero`
* `isIEEE`
* `isInfinite`
* `isJust`
* `isLeft`
* `isNaN`
* `isNegativeZero`
* `isNothing`
* `isPrefixOf`
* `isRight`
* `isSigned`
* `iterate`
* `join`
* `killThread`
* `lastDef`
* `lastMay`
* `lcm`
* `leDouble`
* `leFloat`
* `leInteger`
* `leInteger#`
* `leftToMaybe`
* `lefts`
* `length`
* `lift`
* `liftA`
* `liftA2`
* `liftA3`
* `liftIO`
* `liftM`
* `liftM'`
* `liftM2`
* `liftM2'`
* `liftM3`
* `liftM4`
* `liftM5`
* `link`
* `link2`
* `list`
* `listToMaybe`
* `local`
* `log`
* `logBase`
* `logDouble`
* `logFloat`
* `ltDouble`
* `ltFloat`
* `ltInteger`
* `ltInteger#`
* `magnitude`
* `many`
* `map`
* `mapAccumL`
* `mapAccumR`
* `mapAndUnzipM`
* `mapConcurrently`
* `mapException`
* `mapM`
* `mapM_`
* `mapMaybe`
* `mappend`
* `mask`
* `mask_`
* `max`
* `maxBound`
* `maxExpt`
* `maxExpt10`
* `maxInt`
* `maximum`
* `maximumBy`
* `maybe`
* `maybeToEither`
* `maybeToLeft`
* `maybeToList`
* `maybeToRight`
* `mconcat`
* `mempty`
* `mfilter`
* `min`
* `minBound`
* `minExpt`
* `minInt`
* `minimum`
* `minimumBy`
* `minusDouble`
* `minusFloat`
* `minusInteger`
* `mkInteger`
* `mkPolar`
* `mkWeakMVar`
* `mkWeakThreadId`
* `mod`
* `modInteger`
* `modify`
* `modifyMVar`
* `modifyMVarMasked`
* `modifyMVarMasked_`
* `modifyMVar_`
* `mplus`
* `msum`
* `myThreadId`
* `mzero`
* `neDouble`
* `neFloat`
* `negate`
* `negateDouble`
* `negateFloat`
* `negateInteger`
* `neqInteger`
* `neqInteger#`
* `newChan`
* `newEmptyMVar`
* `newMVar`
* `newQSem`
* `newQSemN`
* `not`
* `notANumber`
* `notElem`
* `notImplemented`
* `null`
* `numerator`
* `numericEnumFrom`
* `numericEnumFromThen`
* `numericEnumFromThenTo`
* `numericEnumFromTo`
* `odd`
* `on`
* `onException`
* `one`
* `openFile`
* `optional`
* `or`
* `orAlt`
* `orElse`
* `orEmpty`
* `orInteger`
* `ord`
* `ordNub`
* `otherwise`
* `overflowError`
* `panic`
* `partitionEithers`
* `permutations`
* `phase`
* `pi`
* `plusDouble`
* `plusFloat`
* `plusInteger`
* `polar`
* `poll`
* `pollSTM`
* `popCount`
* `popCountDefault`
* `powerDouble`
* `powerFloat`
* `pred`
* `predError`
* `print`
* `product`
* `properFraction`
* `pure`
* `put`
* `putLText`
* `putMVar`
* `putStr`
* `putStrLn`
* `putText`
* `quot`
* `quotInteger`
* `quotRem`
* `quotRemInteger`
* `race`
* `race_`
* `ratioPrec`
* `ratioPrec1`
* `ratioZeroDenominatorError`
* `rationalToDouble`
* `rationalToFloat`
* `readChan`
* `readEither`
* `readFile`
* `readMVar`
* `readMaybe`
* `reader`
* `reads`
* `realPart`
* `realToFrac`
* `recip`
* `reduce`
* `rem`
* `remInteger`
* `repeat`
* `replicate`
* `replicateM`
* `replicateM_`
* `retry`
* `return`
* `reverse`
* `rightToMaybe`
* `rights`
* `rnf`
* `rotate`
* `rotateL`
* `rotateR`
* `round`
* `roundTo`
* `rtsSupportsBoundThreads`
* `runConcurrently`
* `runExcept`
* `runExceptT`
* `runIdentity`
* `runInBoundThread`
* `runInUnboundThread`
* `runReader`
* `runReaderT`
* `runST`
* `runState`
* `runStateT`
* `scaleFloat`
* `scanl`
* `scanl'`
* `scanr`
* `second`
* `selName`
* `seq`
* `sequence`
* `sequenceA`
* `sequenceA_`
* `sequence_`
* `setBit`
* `setNumCapabilities`
* `shift`
* `shiftL`
* `shiftLInteger`
* `shiftR`
* `shiftRInteger`
* `show`
* `signalQSem`
* `signalQSemN`
* `significand`
* `signum`
* `signumInteger`
* `sin`
* `sinDouble`
* `sinFloat`
* `sinh`
* `sinhDouble`
* `sinhFloat`
* `smallInteger`
* `snd`
* `some`
* `sort`
* `sortBy`
* `sortOn`
* `splitAt`
* `sqrt`
* `sqrtDouble`
* `sqrtFloat`
* `stToIO`
* `state`
* `stderr`
* `stdin`
* `stdout`
* `strConv`
* `subsequences`
* `subtract`
* `succ`
* `succError`
* `sum`
* `swap`
* `swapMVar`
* `sym`
* `tailDef`
* `tailMay`
* `tailSafe`
* `tails`
* `take`
* `takeMVar`
* `takeWhile`
* `tan`
* `tanDouble`
* `tanFloat`
* `tanh`
* `tanhDouble`
* `tanhFloat`
* `testBit`
* `testBitDefault`
* `testBitInteger`
* `threadCapability`
* `threadDelay`
* `threadWaitRead`
* `threadWaitReadSTM`
* `threadWaitWrite`
* `threadWaitWriteSTM`
* `throwError`
* `throwIO`
* `throwSTM`
* `throwTo`
* `timesDouble`
* `timesFloat`
* `timesInteger`
* `to`
* `toEnum`
* `toEnumError`
* `toException`
* `toInteger`
* `toIntegralSized`
* `toList`
* `toRational`
* `toS`
* `toSL`
* `toStrict`
* `trace`
* `traceIO`
* `traceM`
* `traceShow`
* `traceShowM`
* `trans`
* `transpose`
* `traverse`
* `traverse_`
* `truncate`
* `try`
* `tryJust`
* `tryPutMVar`
* `tryReadMVar`
* `tryTakeMVar`
* `typeRep`
* `unGetChan`
* `unK1`
* `unM1`
* `uncons`
* `uncurry`
* `undefined`
* `unfoldr`
* `uninterruptibleMask`
* `uninterruptibleMask_`
* `unless`
* `unlessM`
* `unsnoc`
* `vacuous`
* `void`
* `wait`
* `waitAny`
* `waitAnyCancel`
* `waitAnyCatch`
* `waitAnyCatchCancel`
* `waitAnyCatchSTM`
* `waitAnySTM`
* `waitBoth`
* `waitBothSTM`
* `waitCatch`
* `waitCatchSTM`
* `waitEither`
* `waitEitherCancel`
* `waitEitherCatch`
* `waitEitherCatchCancel`
* `waitEitherCatchSTM`
* `waitEitherSTM`
* `waitEitherSTM_`
* `waitEither_`
* `waitQSem`
* `waitQSemN`
* `waitSTM`
* `when`
* `whenM`
* `withAsync`
* `withAsyncBound`
* `withAsyncOn`
* `withAsyncOnWithUnmask`
* `withAsyncWithUnmask`
* `withFile`
* `withMVar`
* `withMVarMasked`
* `withState`
* `word2Double`
* `word2Float`
* `wordToInteger`
* `writeChan`
* `writeFile`
* `writeList2Chan`
* `xor`
* `xorInteger`
* `yield`
* `zero`
* `zeroBits`
* `zip`
* `zipWith`
* `zipWithM`
* `zipWithM_`
* `||`