forM package:rebase

forM is mapM with its arguments flipped. For a version that ignores the results see forM_.

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore the results see forM. forM_ is just like for_, but specialised to monadic actions.

Substitute various time-related information for each %-code in the string, as per formatCharacter. The general form is %<modifier><width><alternate><specifier>, where <modifier>, <width>, and <alternate> are optional.

<modifier>

glibc-style modifiers can be used before the specifier (here marked as z):

• %-z no padding
• %_z pad with spaces
• %0z pad with zeros
• %^z convert to upper case
• %#z convert to lower case (consistently, unlike glibc)

<width>

Width digits can also be used after any modifiers and before the specifier (here marked as z), for example:

• %4z pad to 4 characters (with default padding character)
• %_12z pad with spaces to 12 characters

<alternate>

An optional E character indicates an alternate formatting. Currently this only affects %Z and %z.

• %Ez alternate formatting

<specifier>

For all types (note these three are done by formatTime, not by formatCharacter):

• %% %
• %t tab
• %n newline

TimeZone

For TimeZone (and ZonedTime and UTCTime):

• %z timezone offset in the format ±HHMM
• %Ez timezone offset in the format ±HH:MM
• %Z timezone name (or else offset in the format ±HHMM)
• %EZ timezone name (or else offset in the format ±HH:MM)

LocalTime

For LocalTime (and ZonedTime and UTCTime and UniversalTime):

• %c as dateTimeFmt locale (e.g. %a %b %e %H:%M:%S %Z %Y)

TimeOfDay

For TimeOfDay (and LocalTime and ZonedTime and UTCTime and UniversalTime):

• %R same as %H:%M
• %T same as %H:%M:%S
• %X as timeFmt locale (e.g. %H:%M:%S)
• %r as time12Fmt locale (e.g. %I:%M:%S %p)
• %P day-half of day from (amPm locale), converted to lowercase, am, pm
• %p day-half of day from (amPm locale), AM, PM
• %H hour of day (24-hour), 0-padded to two chars, 00 - 23
• %k hour of day (24-hour), space-padded to two chars, 0 - 23
• %I hour of day-half (12-hour), 0-padded to two chars, 01 - 12
• %l hour of day-half (12-hour), space-padded to two chars, 1 - 12
• %M minute of hour, 0-padded to two chars, 00 - 59
• %S second of minute (without decimal part), 0-padded to two chars, 00 - 60
• %q picosecond of second, 0-padded to twelve chars, 000000000000 - 999999999999.
• %Q decimal point and fraction of second, up to 12 second decimals, without trailing zeros. For a whole number of seconds, %Q omits the decimal point unless padding is specified.

UTCTime and ZonedTime

For UTCTime and ZonedTime:

• %s number of whole seconds since the Unix epoch. For times before the Unix epoch, this is a negative number. Note that in %s.%q and %s%Q the decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as -1.1 with %s%Q.

DayOfWeek

For DayOfWeek (and Day and LocalTime and ZonedTime and UTCTime and UniversalTime):

• %u day of week number for Week Date format, 1 (= Monday) - 7 (= Sunday)
• %w day of week number, 0 (= Sunday) - 6 (= Saturday)
• %a day of week, short form (snd from wDays locale), Sun - Sat
• %A day of week, long form (fst from wDays locale), Sunday - Saturday

Month

For Month (and Day and LocalTime and ZonedTime and UTCTime and UniversalTime):

• %Y year, no padding. Note %0Y and %_Y pad to four chars
• %y year of century, 0-padded to two chars, 00 - 99
• %C century, no padding. Note %0C and %_C pad to two chars
• %B month name, long form (fst from months locale), January - December
• %b, %h month name, short form (snd from months locale), Jan - Dec
• %m month of year, 0-padded to two chars, 01 - 12

Day

For Day (and LocalTime and ZonedTime and UTCTime and UniversalTime):

• %D same as %m/%d/%y
• %F same as %Y-%m-%d
• %x as dateFmt locale (e.g. %m/%d/%y)
• %d day of month, 0-padded to two chars, 01 - 31
• %e day of month, space-padded to two chars, 1 - 31
• %j day of year, 0-padded to three chars, 001 - 366
• %f century for Week Date format, no padding. Note %0f and %_f pad to two chars
• %V week of year for Week Date format, 0-padded to two chars, 01 - 53
• %U week of year where weeks start on Sunday (as sundayStartWeek), 0-padded to two chars, 00 - 53
• %W week of year where weeks start on Monday (as mondayStartWeek), 0-padded to two chars, 00 - 53

Duration types

The specifiers for DiffTime, NominalDiffTime, CalendarDiffDays, and CalendarDiffTime are semantically separate from the other types. Specifiers on negative time differences will generally be negative (think rem rather than mod).

NominalDiffTime and DiffTime

Note that a "minute" of DiffTime is simply 60 SI seconds, rather than a minute of civil time. Use NominalDiffTime to work with civil time, ignoring any leap seconds. For NominalDiffTime and DiffTime:

• %w total whole weeks
• %d total whole days
• %D whole days of week
• %h total whole hours
• %H whole hours of day
• %m total whole minutes
• %M whole minutes of hour
• %s total whole seconds
• %Es total seconds, with decimal point and up to <width> (default 12) decimal places, without trailing zeros. For a whole number of seconds, %Es omits the decimal point unless padding is specified.
• %0Es total seconds, with decimal point and <width> (default 12) decimal places.
• %S whole seconds of minute
• %ES seconds of minute, with decimal point and up to <width> (default 12) decimal places, without trailing zeros. For a whole number of seconds, %ES omits the decimal point unless padding is specified.
• %0ES seconds of minute as two digits, with decimal point and <width> (default 12) decimal places.

CalendarDiffDays

For CalendarDiffDays (and CalendarDiffTime):

• %y total years
• %b total months
• %B months of year
• %w total weeks, not including months
• %d total days, not including months
• %D days of week

CalendarDiffTime

For CalendarDiffTime:

• %h total hours, not including months
• %H hours of day
• %m total minutes, not including months
• %M minutes of hour
• %s total whole seconds, not including months
• %Es total seconds, not including months, with decimal point and up to <width> (default 12) decimal places, without trailing zeros. For a whole number of seconds, %Es omits the decimal point unless padding is specified.
• %0Es total seconds, not including months, with decimal point and <width> (default 12) decimal places.
• %S whole seconds of minute
• %ES seconds of minute, with decimal point and up to <width> (default 12) decimal places, without trailing zeros. For a whole number of seconds, %ES omits the decimal point unless padding is specified.
• %0ES seconds of minute as two digits, with decimal point and <width> (default 12) decimal places.

Cf: Other, Format

Construct format string according to ISO-8601. The Maybe String argument allows to supply an optional time specification. E.g.:

iso8601DateFormat Nothing            == "%Y-%m-%d"           -- i.e. YYYY-MM-DD
iso8601DateFormat (Just "%H:%M:%S")  == "%Y-%m-%dT%H:%M:%S"  -- i.e. YYYY-MM-DDTHH:MM:SS

The most commonly used ISO 8601 format for this type.

Triggers an immediate major garbage collection.

Triggers an immediate major garbage collection.

Triggers an immediate minor garbage collection.

Format string according to RFC822.

This version of unsafePerformIO is more efficient because it omits the check that the IO is only being performed by a single thread. Hence, when you use unsafeDupablePerformIO, there is a possibility that the IO action may be performed multiple times (on a multiprocessor), and you should therefore ensure that it gives the same results each time. It may even happen that one of the duplicated IO actions is only run partially, and then interrupted in the middle without an exception being raised. Therefore, functions like bracket cannot be used safely within unsafeDupablePerformIO.

This is the "back door" into the IO monad, allowing IO computation to be performed at any time. For this to be safe, the IO computation should be free of side effects and independent of its environment. If the I/O computation wrapped in unsafePerformIO performs side effects, then the relative order in which those side effects take place (relative to the main I/O trunk, or other calls to unsafePerformIO) is indeterminate. Furthermore, when using unsafePerformIO to cause side-effects, you should take the following precautions to ensure the side effects are performed as many times as you expect them to be. Note that these precautions are necessary for GHC, but may not be sufficient, and other compilers may require different precautions:

• Use {-# NOINLINE foo #-} as a pragma on any function foo that calls unsafePerformIO. If the call is inlined, the I/O may be performed more than once.
• Use the compiler flag -fno-cse to prevent common sub-expression elimination being performed on the module, which might combine two side effects that were meant to be separate. A good example is using multiple global variables (like test in the example below).
• Make sure that the either you switch off let-floating (-fno-full-laziness), or that the call to unsafePerformIO cannot float outside a lambda. For example, if you say: f x = unsafePerformIO (newIORef []) you may get only one reference cell shared between all calls to f. Better would be f x = unsafePerformIO (newIORef [x]) because now it can't float outside the lambda.

It is less well known that unsafePerformIO is not type safe. For example:

test :: IORef [a]
test = unsafePerformIO $ newIORef []

main = do
writeIORef test [42]
bang <- readIORef test
print (bang :: [Char])

This program will core dump. This problem with polymorphic references is well known in the ML community, and does not arise with normal monadic use of references. There is no easy way to make it impossible once you use unsafePerformIO. Indeed, it is possible to write coerce :: a -> b with the help of unsafePerformIO. So be careful! WARNING: If you're looking for "a way to get a String from an 'IO String'", then unsafePerformIO is not the way to go. Learn about do-notation and the <- syntax element before you proceed.