From 1cb06305292cb01719251891365496de2c20b850 Mon Sep 17 00:00:00 2001 From: Stephen Diehl Date: Thu, 21 Jul 2016 14:49:09 -0400 Subject: [PATCH] New symbol documentation. --- Symbols.md | 1909 ++++++++++++++++++++++---------------------------- src/Monad.hs | 1 + 2 files changed, 858 insertions(+), 1052 deletions(-) diff --git a/Symbols.md b/Symbols.md index 179fa1f8c..93cf202e9 100644 --- a/Symbols.md +++ b/Symbols.md @@ -1,1125 +1,906 @@ -* Applicative -* Bool -* Monad -* Show -* Either -* Functor -* Semiring -* Bifunctor -* Exception -* Coercion -* TypeRep -* State -* Foldable -* Traversable -* Maybe -* Monoid -* String -* Bounded -* Enum -* Floating -* RealFloat -* Num -* Fractional -* Integral -* Rational -* Real -* RealFrac -* FilePath -* Double# -* Float# -* RealWorld -* Any -* Constraint -* Char -* Double -* Float -* Int -* Word -* Coercible -* V1 -* U1 -* K1 -* M1 -* :+: +* $ +* $! +* $!! +* $> +* % +* & +* && +* * +* ** +* *> +* + +* ++ +* - +* . +* .&. +* .|. +* / +* /= +* :% * :*: -* Rec0 -* D1 -* C1 -* S1 -* Rep -* IO -* Ratio -* Integer -* Eq -* Ord -* IsString -* Alternative -* Typeable +* :+ +* :+: +* :~: +* < +* <$ +* <$!> +* <$> +* <* +* <**> +* <*> +* <.> +* <= +* <=< +* <> +* <|> +* =<< * == -* Read -* Ptr +* == +* > +* >= +* >=> +* >> +* >>= +* 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 -* Int8 +* Functor +* GT +* Generic +* Handle +* Handler +* Handler +* HeapOverflow +* IO +* IOException +* IOMode +* Identity +* Identity +* IndexOutOfBounds +* Infix +* Int +* Int * Int16 * Int32 * Int64 -* Word8 +* 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 +* String +* StringConv +* Sum +* Sum +* Text +* ThreadId +* ThreadKilled +* Traversable +* True +* TypeRep +* Typeable +* U1 +* U1 +* UndefinedElement +* Underflow +* Unmasked +* UserInterrupt +* V1 +* Void +* Word +* Word * Word16 * Word32 * Word64 -* MonadPlus -* Ordering -* Generic -* Constructor -* Selector -* FFFormat -* Const -* ZipList -* Identity -* NFData -* Map -* Set -* Seq -* IntMap -* IntSet -* Proxy -* :~: -* Void -* MonadState -* StateT -* Reader -* MonadReader -* ReaderT -* Except -* MonadError -* ExceptT -* MonadIO -* Bits -* Complex -* Fixity -* ByteString -* ByteString -* Text -* Text -* Handle -* IOMode -* ST -* STM -* Async -* Storable -* FatalError -* StringConv -* Leniency -* Print -* All -* Alt -* Dual -* Endo -* First -* Last -* Product -* Sum -* Down -* SomeException -* IOException -* FiniteBits -* NestedAtomically -* NoMethodError -* NonTermination -* PatternMatchFail -* RecConError -* RecSelError -* RecUpdError -* ArithException -* ErrorCall -* MaskingState -* Handler -* AllocationLimitExceeded -* ArrayException -* AssertionFailed -* AsyncException -* BlockedIndefinitelyOnMVar -* BlockedIndefinitelyOnSTM -* Deadlock -* SomeAsyncException -* ThreadId -* ExitCode -* Chan -* QSem -* QSemN -* MVar -* Concurrently -* Coercion -* Left -* Right -* Just -* Nothing -* Any -* False -* True -* D# -* F# -* U1 -* K1 -* M1 -* :% -* LT -* EQ -* GT -* FFExponent -* FFFixed -* FFGeneric -* Const -* ZipList -* Identity -* Proxy -* FatalError -* All -* Alt -* Dual -* Endo -* First -* Last -* Product -* Sum -* Prefix -* Infix -* Refl -* Down -* AppendMode -* ReadMode -* ReadWriteMode +* Word8 * WriteMode -* SomeException -* Lenient -* Strict -* NestedAtomically -* NoMethodError -* NonTermination -* PatternMatchFail -* RecConError -* RecSelError -* RecUpdError -* Denormal -* DivideByZero -* ErrorCall -* LossOfPrecision -* Overflow -* RatioZeroDenominator -* Underflow -* MaskedInterruptible -* MaskedUninterruptible -* Unmasked -* Handler -* AllocationLimitExceeded -* IndexOutOfBounds -* UndefinedElement -* AssertionFailed -* HeapOverflow -* StackOverflow -* ThreadKilled -* UserInterrupt -* BlockedIndefinitelyOnMVar -* BlockedIndefinitelyOnSTM -* Deadlock -* SomeAsyncException -* :+ -* ExitFailure -* ExitSuccess -* Concurrently -* deepseq -* split -* split -* async -* void -* smallInteger -* wordToInteger -* integerToWord -* integerToInt -* plusInteger -* minusInteger -* timesInteger -* negateInteger -* eqInteger# -* neqInteger# +* ZipList +* ZipList +* ^ +* ^%^ +* ^^ +* ^^%^^ +* abs * absInteger -* signumInteger -* leInteger# -* gtInteger# -* ltInteger# -* geInteger# -* compareInteger -* encodeFloatInteger -* floatFromInteger -* encodeDoubleInteger -* decodeDoubleInteger -* doubleFromInteger -* rationalToFloat -* rationalToDouble -* andInteger -* orInteger -* xorInteger -* complementInteger -* shiftLInteger -* shiftRInteger -* quotInteger -* remInteger -* divInteger -* modInteger -* divModInteger -* quotRemInteger -* group -* group -* group -* either -* all -* all +* absurd +* acos +* acosDouble +* acosFloat +* acosh +* addMVarFinalizer * all +* allowInterrupt +* always +* alwaysSucceeds * and +* andInteger * any -* any -* any -* concat -* concat -* concat -* concatMap -* concatMap -* concatMap -* elem -* elem -* foldMap -* foldl -* foldl -* foldl -* foldl1 -* foldl1 -* foldr -* foldr -* foldr -* foldr1 -* foldr1 -* length -* length -* length -* mapM_ -* maximum -* maximum -* maximum -* minimum -* minimum -* minimum -* notElem -* notElem -* null -* null -* null -* or -* product -* sequence_ -* sum -* <$> -* maybe -* mapM -* sequence -* sequenceA -* traverse -* curry -* fst -* snd -* uncurry -* $! -* *> -* ++ -* . -* <$ -* <* -* <*> -* =<< -* >>= +* 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 -* flip -* fmap -* map -* map -* mappend -* mconcat -* mempty -* otherwise -* pure -* return +* 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 -* fromEnum -* maxBound -* minBound -* pred -* succ -* toEnum -* ** -* acos -* acosh -* asin -* asinh -* atan -* atan2 -* atanh -* cos -* cosh -* decodeFloat -* encodeFloat +* eqDouble +* eqFloat +* eqInteger +* eqInteger# +* eqT +* error +* evalState +* evalStateT +* evaluate +* even +* execState +* execStateT +* exitFailure +* exitSuccess +* exitWith * exp +* expDouble +* expFloat * exponent +* expt +* expts +* expts10 +* 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 +* 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 -* log -* logBase -* pi -* scaleFloat -* significand -* sin -* sinh -* sqrt -* tan -* tanh -* * -* + -* - -* abs -* fromInteger -* negate -* signum -* subtract -* / -* ^ -* ^^ -* ceiling -* div -* divMod -* even -* floor -* fromIntegral -* fromRational -* gcd -* lcm -* mod -* odd -* properFraction -* quot -* quotRem -* realToFrac -* recip -* rem -* round -* toInteger -* toRational -* truncate -* show -* showList -* showsPrec -* appendFile -* appendFile -* getContents -* getContents -* getLine -* interact -* interact -* print -* putStr -* putStr -* putStr -* putStr -* putStrLn -* putStrLn -* putStrLn -* putStrLn -* readFile -* readFile -* writeFile -* writeFile -* reads -* lines -* unlines -* unwords -* words -* ioError -* break -* break -* break -* cycle -* cycle -* cycle -* drop -* drop -* drop -* dropWhile -* dropWhile -* dropWhile -* head -* head -* head -* init -* init +* isNothing +* isPrefixOf +* isRight +* isSigned * iterate -* iterate -* iterate -* last -* last -* repeat -* repeat -* repeat -* replicate -* replicate -* replicate -* reverse -* reverse -* reverse -* scanl -* scanl -* scanl -* scanl1 -* scanr -* scanr -* scanr1 -* span -* span -* splitAt -* splitAt -* splitAt -* tail -* tail -* take -* take -* take -* takeWhile -* takeWhile -* takeWhile -* unzip -* zipWith -* zipWith -* zipWith -* && -* not -* || -* /= -* < -* <= -* > -* compare -* max -* min -* $ -* error -* error -* undefined -* undefined -* seq -* >= -* == * join -* first -* toList -* filter -* filter -* filter -* zip -* zip -* zip -* assert -* mkInteger -* guard -* liftM +* killThread +* lastDef +* lastMay +* lcm +* leDouble +* leFloat +* leInteger +* leInteger# +* leftToMaybe +* lefts +* length * lift -* <|> -* <**> -* empty -* empty -* empty -* some -* many -* mzero -* mplus -* ap * 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 -* ord -* when -* unpack -* unpack -* .&. -* shiftL -* shiftR -* double2Int -* float2Int -* int2Double -* int2Float -* denominator +* minimum +* minimumBy +* minusDouble +* minusFloat +* minusInteger +* mkInteger +* mkPolar +* mkWeakMVar +* mkWeakThreadId +* mod +* modInteger +* modify +* modifyMVar +* modifyMVarMasked +* modifyMVarMasked_ +* modifyMVar_ +* mplus +* msg +* 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 -* isDoubleDenormalized -* isDoubleInfinite -* isDoubleNaN -* isDoubleNegativeZero -* isFloatDenormalized -* isFloatInfinite -* isFloatNaN -* isFloatNegativeZero -* isDoubleFinite -* isFloatFinite -* acosDouble -* acosFloat -* asinDouble -* asinFloat -* atanDouble -* atanFloat -* clamp -* cosDouble -* cosFloat -* coshDouble -* coshFloat -* divideDouble -* divideFloat -* double2Float -* eqDouble -* eqFloat -* expDouble -* expFloat -* expt -* expts -* expts10 -* float2Double -* floatToDigits -* formatRealFloat -* formatRealFloatAlt -* fromRat -* fromRat' -* fromRat'' -* geDouble -* geFloat -* gtDouble -* gtFloat -* integerLogBase -* leDouble -* leFloat -* logDouble -* logFloat -* ltDouble -* ltFloat -* maxExpt -* maxExpt10 -* minExpt -* minusDouble -* minusFloat -* neDouble -* neFloat -* negateDouble -* negateFloat +* 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 -* roundTo -* showFloat -* showSignedFloat -* sinDouble -* sinFloat -* sinhDouble -* sinhFloat -* sqrtDouble -* sqrtFloat -* tanDouble -* tanFloat -* tanhDouble -* tanhFloat -* timesDouble -* timesFloat -* word2Double -* word2Float -* eqInteger -* divZeroError -* uncons -* uncons -* headMay -* headDef -* initMay -* initDef -* initSafe -* tailMay -* tailDef -* tailSafe -* lastDef -* lastMay -* foldr1May -* foldl1May -* atMay -* atDef -* optional -* $!! -* force -* intercalate -* intercalate -* intercalate -* isPrefixOf -* isPrefixOf -* isPrefixOf -* sortBy -* sort -* intersperse -* intersperse -* intersperse -* transpose -* transpose -* transpose -* subsequences -* permutations -* unfoldr -* unfoldr -* unfoldr -* inits -* inits -* inits -* tails -* tails -* tails -* typeRep -* cast -* eqT -* coerceWith -* sym -* trans -* castWith -* gcastWith -* absurd -* vacuous -* put -* get -* gets -* modify -* withState -* runState -* execState -* evalState -* runStateT -* execStateT -* evalStateT -* ask -* asks -* local -* runReader -* runReaderT -* throwError -* catchError -* runExcept -* runExceptT -* liftIO -* chr -* bool -* fix -* on -* toStrict -* toStrict -* fromStrict -* fromStrict -* getArgs -* stdin -* stdout -* stderr -* withFile -* openFile -* readMaybe -* readEither -* zero -* panic -* toS -* toSL -* orAlt -* orEmpty -* eitherA -* maybeToLeft -* maybeToRight -* leftToMaybe -* rightToMaybe -* maybeToEither -* $> -* >=> -* <=< -* forever -* mfilter -* filterM -* mapAndUnzipM -* zipWithM -* zipWithM_ -* foldM -* foldM_ -* replicateM -* replicateM_ -* concatMapM -* unless -* liftM' -* liftM2' -* <$!> -* trace -* traceM -* traceIO -* traceShow -* traceShowM -* notImplemented -* whenM -* unlessM -* ifM -* guardM -* putText -* putLText -* ordNub -* sortOn -* list -* comparing -* one -* <.> -* conIsRecord -* conName -* from -* selName -* to -* <> -* getAll -* getAlt -* getAny -* getDual -* appEndo -* getFirst -* getLast -* getProduct -* getSum -* isLeft -* isRight -* lefts -* partitionEithers -* rights -* conFixity -* unK1 -* unM1 -* geInteger -* gtInteger -* hashInteger -* leInteger -* ltInteger -* neqInteger -* testBitInteger -* catMaybes -* fromMaybe -* isJust -* isNothing -* listToMaybe -* mapMaybe -* cons -* cons -* maybeToList -* find -* find -* find -* foldl' -* foldl' -* foldl' -* maximumBy -* minimumBy -* dropWhileEnd -* elemIndex -* elemIndices -* findIndex -* findIndices -* groupBy -* groupBy -* isInfixOf -* isSuffixOf -* isSuffixOf -* partition -* partition -* stripPrefix -* mapAccumL -* mapAccumL -* mapAccumL -* mapAccumR -* mapAccumR -* mapAccumR -* foldl1' -* foldl1' -* fold -* foldr' -* asum -* foldlM -* foldrM -* forM_ -* for_ -* msum -* sequenceA_ -* traverse_ -* forM -* singleton -* singleton -* link -* getConst -* getZipList -* boundedEnumFrom -* boundedEnumFromThen -* fromEnumError +* pred * predError -* succError -* toEnumError -* % -* ^%^ -* ^^%^^ -* gcdInt' -* gcdWord' -* infinity -* integralEnumFrom -* integralEnumFromThen -* integralEnumFromThenTo -* integralEnumFromTo -* notANumber -* overflowError +* 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 -* showSigned -* bracket -* .|. -* hGetContents -* hGetContents -* hGetLine -* hPutStr -* hPutStr -* hPutStrLn -* newEmptyMVar -* putMVar -* takeMVar -* index -* index -* unfoldrN -* append -* append -* snoc -* snoc -* toCaseFold -* toLower -* toTitle -* toUpper -* breakOn -* breakOnAll -* breakOnEnd -* center -* chunksOf -* commonPrefixes -* compareLength -* copy -* count -* count -* dropAround -* dropEnd -* justifyLeft -* justifyRight -* pack -* pack -* replace -* second -* splitOn -* strip -* stripEnd -* stripStart -* stripSuffix -* takeEnd -* takeWhileEnd -* msg -* hPut -* mask -* runIdentity -* fmapDefault -* foldMapDefault -* for -* runST -* elemIndexEnd -* hGet -* hGetNonBlocking -* hPutNonBlocking -* splitWith -* unsnoc -* cons' -* fromChunks -* fromChunks -* toChunks -* toChunks -* hGetChunk -* foldlChunks -* foldlChunks -* foldrChunks -* foldrChunks -* strConv -* try -* evaluate -* bit -* bitDefault -* bitSize -* bitSizeMaybe -* complement -* countLeadingZeros -* countTrailingZeros -* finiteBitSize -* isSigned -* popCount -* rotate -* shift -* testBit -* testBitDefault -* unsafeShiftL -* unsafeShiftR -* xor -* byteSwap16 -* byteSwap32 -* byteSwap64 -* throw -* bracketOnError -* bracket_ -* catch -* catchJust -* finally -* handle -* handleJust -* mapException -* onException -* tryJust -* displayException -* fromException -* toException -* getMaskingState -* mask_ -* throwIO -* uninterruptibleMask -* uninterruptibleMask_ -* allowInterrupt -* catches -* throwTo -* asyncExceptionFromException -* asyncExceptionToException -* bimap +* rem +* remInteger +* repeat +* replicate +* replicateM +* replicateM_ +* retry +* return +* reverse +* rightToMaybe +* rights * rnf -* swap +* rotate * rotateL * rotateR -* zeroBits +* round +* roundTo +* rtsSupportsBoundThreads +* runConcurrently +* runExcept +* runExceptT +* runIdentity +* runInBoundThread +* runInUnboundThread +* runReader +* runReaderT +* runST +* runState +* runStateT +* scaleFloat +* scanl +* scanr +* second +* selName +* seq +* sequence +* sequenceA +* sequenceA_ +* sequence_ * setBit -* clearBit -* complementBit -* popCountDefault -* toIntegralSized -* cis -* conjugate -* imagPart -* magnitude -* mkPolar -* phase -* polar -* realPart -* die -* exitFailure -* exitSuccess -* exitWith -* stToIO -* fixST -* check -* always -* alwaysSucceeds -* atomically -* catchSTM -* orElse -* retry -* throwSTM -* dupChan -* getChanContents -* isEmptyChan -* newChan -* readChan -* unGetChan -* writeChan -* writeList2Chan -* addMVarFinalizer -* mkWeakMVar -* modifyMVar -* modifyMVarMasked -* modifyMVarMasked_ -* modifyMVar_ -* swapMVar -* withMVar -* withMVarMasked -* newQSem +* setNumCapabilities +* shift +* shiftL +* shiftLInteger +* shiftR +* shiftRInteger +* show * signalQSem -* waitQSem -* newQSemN * signalQSemN -* waitQSemN +* 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 -* forkIO -* forkIOWithUnmask -* forkOn -* forkOnWithUnmask -* getNumCapabilities -* killThread -* mkWeakThreadId -* myThreadId -* setNumCapabilities -* threadCapability -* yield -* isEmptyMVar -* newMVar -* readMVar +* 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 -* forkFinally -* forkOS -* rtsSupportsBoundThreads -* isCurrentThreadBound -* runInBoundThread -* runInUnboundThread -* asyncThreadId -* runConcurrently -* asyncBound -* asyncOn -* asyncOnWithUnmask -* asyncWithUnmask -* cancel -* cancelWith -* concurrently -* forConcurrently -* link2 -* mapConcurrently -* poll -* pollSTM -* race -* race_ +* typeRep +* unGetChan +* unK1 +* unM1 +* uncons +* uncurry +* undefined +* unfoldr +* uninterruptibleMask +* uninterruptibleMask_ +* unless +* unlessM +* unsnoc +* vacuous +* void * wait * waitAny * waitAnyCancel @@ -1139,9 +920,33 @@ * 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_ +* || diff --git a/src/Monad.hs b/src/Monad.hs index a29c7f7b6..1d9cdda03 100644 --- a/src/Monad.hs +++ b/src/Monad.hs @@ -9,6 +9,7 @@ module Monad ( , (=<<) , (>=>) , (<=<) + , (>>) , forever , join