mod package:relude

Integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

Strict version of modifyTVar.

Lifted version of modifyIORef.

>>> ref <- newIORef 42

>>> modifyIORef ref (\a -> a + 6)

>>> readIORef ref
48

• To avoid space-leaks, see modifyIORef' for stricter updates
• For atomic updates, see atomicModifyIORef

Lifted version of modifyIORef'.

>>> ref <- newIORef 42

>>> modifyIORef' ref (\a -> a + 3)

>>> readIORef ref
45

• For lazier updates, see modifyIORef
• For atomic updates, see atomicModifyIORef'

Monadic state transformer. Maps an old state to a new state inside a state monad. The old state is thrown away.

Main> :t modify ((+1) :: Int -> Int)
modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

A variant of modify in which the computation is strict in the new state.

See openFile

Three kinds of buffering are supported: line-buffering, block-buffering or no-buffering. These modes have the following effects. For output, items are written out, or flushed, from the internal buffer according to the buffer mode:

• line-buffering: the entire output buffer is flushed whenever a newline is output, the buffer overflows, a hFlush is issued, or the handle is closed.
• block-buffering: the entire buffer is written out whenever it overflows, a hFlush is issued, or the handle is closed.
• no-buffering: output is written immediately, and never stored in the buffer.

An implementation is free to flush the buffer more frequently, but not less frequently, than specified above. The output buffer is emptied as soon as it has been written out. Similarly, input occurs according to the buffer mode for the handle:

• line-buffering: when the buffer for the handle is not empty, the next item is obtained from the buffer; otherwise, when the buffer is empty, characters up to and including the next newline character are read into the buffer. No characters are available until the newline character is available or the buffer is full.
• block-buffering: when the buffer for the handle becomes empty, the next block of data is read into the buffer.
• no-buffering: the next input item is read and returned. The hLookAhead operation implies that even a no-buffered handle may require a one-character buffer.

The default buffering mode when a handle is opened is implementation-dependent and may depend on the file system object which is attached to that handle. For most implementations, physical files will normally be block-buffered and terminals will normally be line-buffered.

Lifted version of atomicModifyIORef.

>>> ref <- newIORef 42

>>> atomicModifyIORef ref (\a -> (a, a + 3))
45

>>> readIORef ref
42

• To avoid space-leaks, see atomicModifyIORef' for stricter updates
• If you are not interested in the return value, see atomicModifyIORef_

Lifted version of atomicModifyIORef'.

>>> ref <- newIORef 42

>>> atomicModifyIORef' ref (\a -> (a, a + 3))
45

>>> readIORef ref
42

• For lazier updates, see atomicModifyIORef
• If you are not interested in the return value, see atomicModifyIORef'_

Version of atomicModifyIORef' that discards return value. Useful when you want to update IORef but not interested in the returning result.

>>> ref <- newIORef 42

>>> atomicModifyIORef'_ ref (`div` 2)

>>> readIORef ref
21

Version of atomicModifyIORef that discards return value. Useful when you want to update IORef but not interested in the returning result.

>>> ref <- newIORef 42

>>> atomicModifyIORef_ ref (`div` 2)

>>> readIORef ref
21

simultaneous div and mod. WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.