Safe Haskell | None |
---|---|

Language | Haskell98 |

The standard set of functions and variables available to all programs.

You may use any of these functions and variables without defining them.

## Synopsis

- type Program = IO ()
- drawingOf :: Picture -> Program
- animationOf :: (Number -> Picture) -> Program
- activityOf :: ([Number] -> world, (world, Event) -> world, world -> Picture) -> Program
- debugActivityOf :: ([Number] -> world, (world, Event) -> world, world -> Picture) -> Program
- groupActivityOf :: (Number, [Number] -> state, (state, Event, Number) -> state, (state, Number) -> Picture) -> Program
- data Picture
- codeWorldLogo :: HasCallStack => Picture
- circle :: HasCallStack => Number -> Picture
- solidCircle :: HasCallStack => Number -> Picture
- thickCircle :: HasCallStack => (Number, Number) -> Picture
- rectangle :: HasCallStack => (Number, Number) -> Picture
- solidRectangle :: HasCallStack => (Number, Number) -> Picture
- thickRectangle :: HasCallStack => (Number, Number, Number) -> Picture
- pictures :: HasCallStack => [Picture] -> Picture
- (&) :: HasCallStack => Picture -> Picture -> Picture
- coordinatePlane :: HasCallStack => Picture
- blank :: HasCallStack => Picture
- colored :: HasCallStack => (Picture, Color) -> Picture
- coloured :: HasCallStack => (Picture, Color) -> Picture
- translated :: HasCallStack => (Picture, Number, Number) -> Picture
- scaled :: HasCallStack => (Picture, Number, Number) -> Picture
- dilated :: HasCallStack => (Picture, Number) -> Picture
- rotated :: HasCallStack => (Picture, Number) -> Picture
- reflected :: HasCallStack => (Picture, Number) -> Picture
- clipped :: HasCallStack => (Picture, Number, Number) -> Picture
- polyline :: HasCallStack => [Point] -> Picture
- thickPolyline :: HasCallStack => ([Point], Number) -> Picture
- polygon :: HasCallStack => [Point] -> Picture
- thickPolygon :: HasCallStack => ([Point], Number) -> Picture
- solidPolygon :: HasCallStack => [Point] -> Picture
- curve :: HasCallStack => [Point] -> Picture
- thickCurve :: HasCallStack => ([Point], Number) -> Picture
- closedCurve :: HasCallStack => [Point] -> Picture
- thickClosedCurve :: HasCallStack => ([Point], Number) -> Picture
- solidClosedCurve :: HasCallStack => [Point] -> Picture
- arc :: HasCallStack => (Number, Number, Number) -> Picture
- sector :: HasCallStack => (Number, Number, Number) -> Picture
- thickArc :: HasCallStack => (Number, Number, Number, Number) -> Picture
- lettering :: HasCallStack => Text -> Picture
- styledLettering :: HasCallStack => (Text, Font, TextStyle) -> Picture
- data Font
- data TextStyle
- data Color
- type Colour = Color
- pattern RGBA :: (Number, Number, Number, Number) -> Color
- pattern RGB :: (Number, Number, Number) -> Color
- pattern HSL :: (Number, Number, Number) -> Color
- black :: Color
- white :: Color
- red :: Color
- green :: Color
- blue :: Color
- yellow :: Color
- orange :: Color
- brown :: Color
- pink :: Color
- purple :: Color
- gray :: Color
- grey :: Color
- mixed :: [Color] -> Color
- light :: Color -> Color
- dark :: Color -> Color
- bright :: Color -> Color
- dull :: Color -> Color
- translucent :: Color -> Color
- assortedColors :: [Color]
- lighter :: (Color, Number) -> Color
- darker :: (Color, Number) -> Color
- brighter :: (Color, Number) -> Color
- duller :: (Color, Number) -> Color
- type Point = (Number, Number)
- translatedPoint :: (Point, Number, Number) -> Point
- rotatedPoint :: (Point, Number) -> Point
- reflectedPoint :: (Point, Number) -> Point
- scaledPoint :: (Point, Number, Number) -> Point
- dilatedPoint :: (Point, Number) -> Point
- type Vector = (Number, Number)
- vectorLength :: Vector -> Number
- vectorDirection :: Vector -> Number
- vectorSum :: (Vector, Vector) -> Vector
- vectorDifference :: (Vector, Vector) -> Vector
- scaledVector :: (Vector, Number) -> Vector
- rotatedVector :: (Vector, Number) -> Vector
- dotProduct :: (Vector, Vector) -> Number
- data Event
- = KeyPress !Text
- | KeyRelease !Text
- | PointerPress !Point
- | PointerRelease !Point
- | PointerMovement !Point
- | TextEntry !Text
- | TimePassing !Number

- traced :: (a, Text) -> a
- data Number
- (+) :: Number -> Number -> Number
- (-) :: Number -> Number -> Number
- (*) :: Number -> Number -> Number
- (/) :: HasCallStack => Number -> Number -> Number
- (^) :: HasCallStack => Number -> Number -> Number
- (>) :: Number -> Number -> Truth
- (>=) :: Number -> Number -> Truth
- (<) :: Number -> Number -> Truth
- (<=) :: Number -> Number -> Truth
- max :: (Number, Number) -> Number
- min :: (Number, Number) -> Number
- negate :: Number -> Number
- abs :: Number -> Number
- signum :: Number -> Number
- truncation :: Number -> Number
- rounded :: Number -> Number
- ceiling :: Number -> Number
- floor :: Number -> Number
- quotient :: HasCallStack => (Number, Number) -> Number
- remainder :: HasCallStack => (Number, Number) -> Number
- pi :: Number
- exp :: Number -> Number
- sqrt :: HasCallStack => Number -> Number
- log :: HasCallStack => Number -> Number
- logBase :: HasCallStack => (Number, Number) -> Number
- sin :: Number -> Number
- tan :: Number -> Number
- cos :: Number -> Number
- asin :: HasCallStack => Number -> Number
- atan :: Number -> Number
- acos :: HasCallStack => Number -> Number
- properFraction :: Number -> (Number, Number)
- even :: Number -> Truth
- odd :: Number -> Truth
- gcd :: HasCallStack => (Number, Number) -> Number
- lcm :: HasCallStack => (Number, Number) -> Number
- sum :: [Number] -> Number
- product :: [Number] -> Number
- maximum :: [Number] -> Number
- minimum :: [Number] -> Number
- isInteger :: Number -> Truth
- fromInteger :: Integer -> Number
- fromRational :: Rational -> Number
- fromInt :: Int -> Number
- toInt :: HasCallStack => Number -> Int
- fromDouble :: HasCallStack => Double -> Number
- toDouble :: Number -> Double
- data Text
- fromString :: String -> Text
- toString :: Text -> String
- (<>) :: Text -> Text -> Text
- numberOfCharacters :: Text -> Number
- numberOfWords :: Text -> Number
- numberOfLines :: Text -> Number
- lines :: Text -> [Text]
- unlines :: [Text] -> Text
- words :: Text -> [Text]
- unwords :: [Text] -> Text
- characters :: Text -> [Text]
- printed :: Number -> Text
- joined :: [Text] -> Text
- joinedWith :: ([Text], Text) -> Text
- lowercase :: Text -> Text
- uppercase :: Text -> Text
- startsWith :: (Text, Text) -> Truth
- endsWith :: (Text, Text) -> Truth
- substitution :: (Text, Text, Text) -> Text
- substitutions :: (Text, [(Text, Text)]) -> Text
- (++) :: [a] -> [a] -> [a]
- data Bool
- type Truth = Bool
- ifThenElse :: Truth -> a -> a -> a
- (==) :: a -> a -> Truth
- (/=) :: a -> a -> Truth
- (&&) :: Truth -> Truth -> Truth
- (||) :: Truth -> Truth -> Truth
- not :: Truth -> Truth
- otherwise :: Truth
- permutations :: [a] -> [[a]]
- subsequences :: [a] -> [[a]]
- toOperator :: ((a, b) -> c) -> a -> b -> c
- fromOperator :: (a -> b -> c) -> (a, b) -> c
- firstOfPair :: (a, b) -> a
- secondOfPair :: (a, b) -> b
- error :: HasCallStack => Text -> a
- undefined :: HasCallStack => a
- fail :: HasCallStack => String -> a
- empty :: [a] -> Truth
- contains :: ([a], a) -> Truth
- length :: [a] -> Number
- at :: HasCallStack => ([a], a, Number) -> [a]
- (#) :: HasCallStack => [a] -> Number -> a
- any :: [Truth] -> Truth
- all :: [Truth] -> Truth
- none :: [Truth] -> Truth
- repeated :: ([a], Number) -> [a]
- repeating :: [a] -> [a]
- first :: HasCallStack => ([a], Number) -> [a]
- last :: HasCallStack => ([a], Number) -> [a]
- rest :: HasCallStack => ([a], Number) -> [a]
- groups :: ([a], Number) -> [[a]]
- while :: ([a], a -> Truth) -> [a]
- until :: ([a], a -> Truth) -> [a]
- after :: ([a], a -> Truth) -> [a]
- concatenation :: [[a]] -> [a]
- sorted :: [Number] -> [Number]
- reversed :: [a] -> [a]
- unique :: [a] -> [a]
- transposed :: [[a]] -> [[a]]
- shuffled :: ([a], Number) -> [a]
- randomNumbers :: Number -> [Number]
- data IO a

# Entry points

A computer program.

This is a specific task or application that a computer performs. In
CodeWorld, programs are defined using one of the "entry point"
functions, such as `drawingOf`

, `animationOf`

, or `activityOf`

.

drawingOf :: Picture -> Program #

A program that displays a drawing of a single picture.

This is the simplest way to define a program in CodeWorld. The
argument is a `Picture`

.

For example:

program = drawingOf(codeWorldLogo)

animationOf :: (Number -> Picture) -> Program #

activityOf :: ([Number] -> world, (world, Event) -> world, world -> Picture) -> Program #

A program that can interact with a user by responding to pointer and keyboard events and remember state.

To create an activity, you first choose a type for its state, called the "world" type. You will then describe the activity with three arguments:

- A function to create an initial world. The argument to this function is an infinite sequence of random numbers (chosen uniformly between 0 and 1) which you can use to create a different world each time your program is run.
- A function that describes how the world changes when
things happen. The function receives an old world and
an
`Event`

that occurs, and maps it to a new world. - A function that converts a world into a
`Picture`

, used to display the program on the screen.

For example:

program = activityOf(initial, change, picture) initial(randoms) = x0 where x0 = 10 * randoms#1 - 5 change(x, KeyPress("A")) = x - 1 change(x, KeyPress("D")) = x + 1 change(x, other) = x picture(x) = translated(solidCircle(1), x, 0)

In mathematical language, an activity is called a dynamical
system. The world type is known as the phase space of the
system, and the `change`

function is called the dynamics of
the system. The `initial`

and `picture`

functions are not
part of the system, but describe how the program should
simulate and display it.

debugActivityOf :: ([Number] -> world, (world, Event) -> world, world -> Picture) -> Program #

A program that acts just like one built with `activityOf`

,
but offers more tools to pause, rewind, and otherwise
understand the program behavior. This can be used during
development, and then changed back to `activityOf`

once the
program is complete.

groupActivityOf :: (Number, [Number] -> state, (state, Event, Number) -> state, (state, Number) -> Picture) -> Program #

A program that interacts with multiple different users by responding to their pointer and keyboard events.

The arguments to this function are similar `activityOf`

,
except that:

- A first argument, a
`Number`

gives the desired number of players. - The
`change`

function receives an extra argument telling which player intiated the event. - The
`picture`

function receives an extra argument with the player for whom the picture should be built.

The activity will always begin with a "lobby", where players can create new games or join existing games with a code. Once the desired number of players have joined, the activity will begin.

# Pictures

A type for pictures.

Pictures can be created from geometry functions such as `circle`

and `rectangle`

. They can be combined by overlaying them with `&`

.
They can be modified using transformations like `translated`

,
`rotated`

, `dilated`

, `colored`

, and `scaled`

. Ultimately, a picture
can be drawn on the screen using one of the CodeWorld entry points
such as `drawingOf`

.

codeWorldLogo :: HasCallStack => Picture #

The CodeWorld logo.

solidCircle :: HasCallStack => Number -> Picture #

A solid circle, with this radius

thickCircle :: HasCallStack => (Number, Number) -> Picture #

A thick circle, with this radius and line width

rectangle :: HasCallStack => (Number, Number) -> Picture #

A thin rectangle, with this width and height

solidRectangle :: HasCallStack => (Number, Number) -> Picture #

A solid rectangle, with this width and height

thickRectangle :: HasCallStack => (Number, Number, Number) -> Picture #

A thick rectangle, with this width and height and line width

pictures :: HasCallStack => [Picture] -> Picture #

A picture made by drawing this list of pictures, ordered from front to back.

(&) :: HasCallStack => Picture -> Picture -> Picture infixr 0 #

A binary operation that overlays one picture in from of the other.

coordinatePlane :: HasCallStack => Picture #

A coordinate plane.

Adding this to your pictures can help you measure distances more accurately.

Example:

program = drawingOf(myPicture & coordinatePlane) myPicture = ...

translated :: HasCallStack => (Picture, Number, Number) -> Picture #

A picture drawn translated in these directions.

scaled :: HasCallStack => (Picture, Number, Number) -> Picture #

A picture scaled by these factors in the x and y directions.
Factors greater than `1`

stretch the picture larger in that direction, and
less than `1`

squish it smaller in that direction.

Negative factors also reflect the picture across that axis. For example, to mirror
a picture over the x-axis: `scaled(p, -1, 1)`

.

dilated :: HasCallStack => (Picture, Number) -> Picture #

A picture with both dimensions scaled by the given factor.
Factors greater than `1`

make the picture bigger and less than `1`

make it smaller.

Negative factors reflect the picture across the origin, which is the same as rotating it by 180 degrees.

reflected :: HasCallStack => (Picture, Number) -> Picture #

A picture reflected across a line through the origin at this angle, in degrees. For example, an angle of 0 reflects the picture vertically across the x axis, while an angle of 90 reflects the picture horizontally across the y axis, and an agle of 45 reflects the picture across the main diagonal.

clipped :: HasCallStack => (Picture, Number, Number) -> Picture #

A picture clipped to a rectangle of this width and height.

polyline :: HasCallStack => [Point] -> Picture #

A thin sequence of line segments with these endpoints

thickPolyline :: HasCallStack => ([Point], Number) -> Picture #

A thin sequence of line segments, with these endpoints and line width

thickPolygon :: HasCallStack => ([Point], Number) -> Picture #

A thin polygon with these points as vertices

solidPolygon :: HasCallStack => [Point] -> Picture #

A solid polygon with these points as vertices

thickCurve :: HasCallStack => ([Point], Number) -> Picture #

A thick curve passing through these points, with this line width

closedCurve :: HasCallStack => [Point] -> Picture #

A thin closed curve passing through these points.

thickClosedCurve :: HasCallStack => ([Point], Number) -> Picture #

A thick closed curve passing through these points, with this line width.

solidClosedCurve :: HasCallStack => [Point] -> Picture #

A solid closed curve passing through these points.

arc :: HasCallStack => (Number, Number, Number) -> Picture #

A thin arc, starting and ending at these angles, with this radius

sector :: HasCallStack => (Number, Number, Number) -> Picture #

A solid sector of a circle (i.e., a pie slice) starting and ending at these angles, with this radius

thickArc :: HasCallStack => (Number, Number, Number, Number) -> Picture #

A thick arc, starting and ending at these angles, with this radius and line width

styledLettering :: HasCallStack => (Text, Font, TextStyle) -> Picture #

A rendering of text characters, with a specific choice of font and style.

A font in which lettering can be drawn. Fonts are used with the
`styledLettering`

function.

`NamedFont`

may create a program that only works correctly on
computers where that font is installed, so you are encouraged to
use one of the other values.

A style in which lettering can be drawn. Text styles are used
with the `styledLettering`

function.

# Colors

A color.

Colors can be described in several ways:

- Using common color names:
`red`

,`blue`

,`yellow`

,`green`

,`orange`

,`purple`

,`pink`

,`black`

,`white`

,`brown`

, and`gray`

. - Transforming other colors with functions such as
`light`

,`dark`

,`bright`

,`dull`

,`translucent`

, and`mixed`

. - Constructing colors from coordinates in a color space, such
as
`RGB`

,`RGBA`

, or`HSL`

.

Note that transparency is included in a color. Common color
names and the `RGB`

and `HSL`

constructors only produce opaque
colors, but `RGBA`

and the `translucent`

function work with
transparency.

Produces a color by mixing other colors in equal proportion.

The order of colors is unimportant. Colors may be mixed in uneven
proportions by listing a color more than once, such as
`mixed([red, red, orange])`

.

Produces a lighter shade of the given color.

This function may be nested more than once to produce an even
lighter shade, as in `light(light(blue))`

.

Produces a darker shade of the given color.

This function may be nested more than once to produce an even
darker shade, as in `dark(dark(green))`

.

Produces a brighter shade of the given color; that is, less gray and more colorful.

This function may be nested more than once to produce an even
brighter shade, as in `bright(bright(yellow))`

.

Produces a duller shade of the given color; that is, more gray and less colorful.

This function may be nested more than once to produce an even
duller shade, as in `dull(dull(purple))`

.

translucent :: Color -> Color #

Produces a partially transparent color.

This function may be nested more than once to produce an even
more transparent color, as in `translucent(translucent(brown))`

.

assortedColors :: [Color] #

An infinite list of various colors.

The list is chosen to contain a variety of different hues as spread out as possible to create colorful effects.

lighter :: (Color, Number) -> Color #

Increases the luminosity of a color by the given amount.

The amount should be between -1 and 1, where:

`lighter(c, 1)`

is always white, regardless of`c`

.`lighter(c, 0)`

is the same as`c`

.`lighter(c, -1)`

is always black, regardless of`c`

.

darker :: (Color, Number) -> Color #

Decreases the luminosity of a color by the given amount.

The amount should be between -1 and 1, where:

`darker(c, 1)`

is always black, regardless of`c`

.`darker(c, 0)`

is the same as`c`

.`darker(c, -1)`

is always white, regardless of`c`

.

brighter :: (Color, Number) -> Color #

Increases the saturation of a color by the given amount.

The amount should be between -1 and 1, where:

`brighter(c, 1)`

is a fully saturated version of`c`

.`brighter(c, 0)`

is the same as`c`

.`brighter(c, -1)`

is just a shade of gray with no color.

duller :: (Color, Number) -> Color #

Decreases the saturation of a color by the given amount.

The amount should be between -1 and 1, where:

`duller(c, 1)`

is just a shade of gray with no color.`duller(c, 0)`

is the same as`c`

.`duller(c, -1)`

is a fully saturated version of`c`

.

# Points and vectors

type Point = (Number, Number) #

A point in two dimensions. A point is written with the x coordinate first, and the y coordinate second. For example, (3, -2) is the point with x coordinate 3 a y coordinate -2.

rotatedPoint :: (Point, Number) -> Point #

Rotates a given point by given angle, in degrees

reflectedPoint :: (Point, Number) -> Point #

scaledPoint :: (Point, Number, Number) -> Point #

Scales a given point by given x and y scaling factor. Scaling by a negative factor also reflects across that axis.

dilatedPoint :: (Point, Number) -> Point #

Dilates a given point by given uniform scaling factor. Dilating by a negative factor also reflects across the origin.

vectorLength :: Vector -> Number #

The length of the given vector

vectorDirection :: Vector -> Number #

The counter-clockwise angle, in degrees, that a given vector make with the X-axis

vectorDifference :: (Vector, Vector) -> Vector #

The difference of two vectors

scaledVector :: (Vector, Number) -> Vector #

Scales a given vector by a given scalar multiplier

rotatedVector :: (Vector, Number) -> Vector #

Rotates a given vector by a given angle in degrees

dotProduct :: (Vector, Vector) -> Number #

The dot product of two vectors

# Events

An event initiated by the user.

Values of this type represent events that the user triggers when using an interactive program.

Key events describe the key as `Text`

. Most keys are represented
by a single character text string, with the capital letter or other
symbol from the key. Keys that don't correspond to a single
character use longer names from the following list. Keep in mind
that not all of these keys appear on all keyboards.

- Up, Down, Left, and Right for the cursor keys.
- F1, F2, etc. for function keys.
- Backspace
- Tab
- Enter
- Shift
- Ctrl
- Alt
- Esc
- PageUp
- PageDown
- End
- Home
- Insert
- Delete
- CapsLock
- NumLock
- ScrollLock
- PrintScreen
- Break
- Separator
- Cancel
- Help

# Debugging

# Numbers

The type for numbers.

Numbers can be positive or negative, whole or fractional. For example, 5, 3.2, and -10 are all values of the type Number.

## Instances

Enum Number # | |

Eq Number # | |

Floating Number # | |

Fractional Number # | |

Defined in Internal.Num | |

Num Number # | |

Ord Number # | |

Real Number # | |

Defined in Internal.Num toRational :: Number -> Rational | |

RealFloat Number # | |

Defined in Internal.Num floatRadix :: Number -> Integer floatDigits :: Number -> Int floatRange :: Number -> (Int, Int) decodeFloat :: Number -> (Integer, Int) encodeFloat :: Integer -> Int -> Number significand :: Number -> Number scaleFloat :: Int -> Number -> Number isInfinite :: Number -> Bool isDenormalized :: Number -> Bool isNegativeZero :: Number -> Bool | |

RealFrac Number # | |

Show Number # | |

(/) :: HasCallStack => Number -> Number -> Number infixl 7 #

Divides two numbers. The second number should not be zero.

(>=) :: Number -> Number -> Truth infix 4 #

Tells whether one number is greater than or equal to the other.

(<=) :: Number -> Number -> Truth infix 4 #

Tells whether one number is less than or equal to the other.

Gives the absolute value of a number.

If the number if positive or zero, the absolute value is the same as the number. If the number is negative, the absolute value is the opposite of the number.

truncation :: Number -> Number #

Gives the number without its fractional part.

For example, truncate(4.2) is 4, while truncate(-4.7) is -4.

Gives the number rounded to the nearest integer.

For example, round(4.2) is 4, while round(4.7) is 5.

Gives the smallest integer that is greater than or equal to a number.

For example, ceiling(4) is 4, while ceiling(4.1) is 5. With negative numbers, ceiling(-3.5) is -3, since -3 is greater than -3.5.

Gives the largest integer that is less than or equal to a number.

For example, floor(4) is 4, while floor(3.9) is 3. With negative numbers, floor(-3.5) is -4, since -4 is less than -3.5.

quotient :: HasCallStack => (Number, Number) -> Number #

Gives the integer part of the result when dividing two numbers.

For example, 3/2 is 1.5, but quotient(3, 2) is 1, which is the integer part.

remainder :: HasCallStack => (Number, Number) -> Number #

Gives the remainder when dividing two numbers.

For example, remainder(3,2) is 1, which is the remainder when dividing 3 by 2.

The constant pi, which is equal to the ratio between the circumference and diameter of a circle.

pi is approximately 3.14.

Gives the exponential of a number. This is equal to the constant e, raised to the power of the number.

The exp function increases faster and faster very quickly. For example, if t is the current time in seconds, exp(t) will reach a million in about 14 seconds. It will reach a billion in around 21 seconds.

sqrt :: HasCallStack => Number -> Number #

Gives the square root of a number. This is the positive number that, when multiplied by itself, gives the original number back.

The sqrt always increases, but slows down. For example, if t is the current time, sqrt(t) will reach 5 in 25 seconds. But it will take 100 seconds to reach 10, and 225 seconds (almost 4 minutes) to reach 15.

log :: HasCallStack => Number -> Number #

Gives the natural log of a number. This is the opposite of the exp function.

Like sqrt, the log function always increases, but slows down. However, it slows down much sooner than the sqrt function. If t is the current time in seconds, it takes more than 2 minutes for log(t) to reach 5, and more than 6 hours to reach 10!

logBase :: HasCallStack => (Number, Number) -> Number #

Gives the logarithm of the first number, using the base of the second number.

Gives the tangent of an angle, where the angle is measured in degrees.

This is the slope of a line at that angle from horizontal.

asin :: HasCallStack => Number -> Number #

Gives the inverse sine of a value, in degrees.

This is the unique angle between -90 and 90 that has the input as its sine.

Gives the inverse tangent of a value, in degrees.

This is the unique angle between -90 and 90 that has the input as its tangent.

acos :: HasCallStack => Number -> Number #

Gives the inverse cosine of a value, in degrees.

This is the unique angle between 0 and 180 that has the input as its cosine.

properFraction :: Number -> (Number, Number) #

Separates a number into its whole and fractional parts.

For example, properFraction(1.2) is (1, 0.2).

gcd :: HasCallStack => (Number, Number) -> Number #

Gives the greatest common divisor of two numbers.

This is the largest number that divides each of the two parameters. Both parameters must be integers.

lcm :: HasCallStack => (Number, Number) -> Number #

Gives the least common multiple of two numbers.

This is the smallest number that is divisible by both of the two parameters. Both parameters must be integers.

isInteger :: Number -> Truth #

Tells whether a Number is an integer or not.

An integer is a whole number, such as 5, 0, or -10. Numbers with non-zero decimals, like 5.3, are not integers.

fromInteger :: Integer -> Number #

fromRational :: Rational -> Number #

fromDouble :: HasCallStack => Double -> Number #

# Text

fromString :: String -> Text #

numberOfCharacters :: Text -> Number #

numberOfWords :: Text -> Number #

numberOfLines :: Text -> Number #

characters :: Text -> [Text] #

joinedWith :: ([Text], Text) -> Text #

startsWith :: (Text, Text) -> Truth #

substitution :: (Text, Text, Text) -> Text #

Gives the result of replacing one piece of text with another.

For example, `substitution("How do you do?", "do", "be")`

is equal to
`"How be you be?"`

.

substitutions :: (Text, [(Text, Text)]) -> Text #

Gives the result of performing many substitutions in a piece of text. This is commonly used to build text to show in a program, as in this example:

substitutions("Lives: [lives] of 3 Score: [score]", [("[lives]", printed(lives)), ("[score]", printed(score))])

# General purpose functions

## Instances

Bounded Bool | |

Enum Bool | |

Eq Bool | |

Ord Bool | |

Read Bool | |

Show Bool | |

Generic Bool | |

Lift Bool | |

Defined in Language.Haskell.TH.Syntax | |

Bits Bool | |

Defined in Data.Bits | |

FiniteBits Bool | |

Defined in Data.Bits | |

Random Bool | |

Unbox Bool | |

Defined in Data.Vector.Unboxed.Base | |

SingKind Bool | |

Vector Vector Bool | |

Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) basicLength :: Vector Bool -> Int basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () | |

MVector MVector Bool | |

Defined in Data.Vector.Unboxed.Base basicLength :: MVector s Bool -> Int basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) | |

SingI False | |

Defined in GHC.Generics | |

SingI True | |

Defined in GHC.Generics | |

type Rep Bool | |

Defined in GHC.Generics | |

newtype Vector Bool | |

Defined in Data.Vector.Unboxed.Base | |

type DemoteRep Bool | |

Defined in GHC.Generics | |

data Sing (a :: Bool) | |

newtype MVector s Bool | |

Defined in Data.Vector.Unboxed.Base |

ifThenElse :: Truth -> a -> a -> a #

(/=) :: a -> a -> Truth infix 4 #

Compares values to see if they are not equal.
Note that `a /= b`

is the same as `not (a == b)`

.

permutations :: [a] -> [[a]] #

subsequences :: [a] -> [[a]] #

toOperator :: ((a, b) -> c) -> a -> b -> c #

Converts a function to an operator.

Example use:

f(x,y) = 2*x + y (%) = toOperator(f) eight = 3 % 2

This has the same effect as defining % as:

x % y = 2*x + y eight = 3 % 2

fromOperator :: (a -> b -> c) -> (a, b) -> c #

Converts an operator into a normal function.

Example use:

divide = fromOperator(/) four = divide(16, 4)

firstOfPair :: (a, b) -> a #

Returns the first element of an ordered pair.

secondOfPair :: (a, b) -> b #

Returns the second element of an ordered pair.

undefined :: HasCallStack => a #

Represents an undefined value. This lets you compile programs with unfinished values. If the value is needed, the program will crash.

fail :: HasCallStack => String -> a #

Fails with an error message. This is required (though apparently unused) by the desugaring for pattern binds in list comprehensions.

at :: HasCallStack => ([a], a, Number) -> [a] #

Gives a list with a replaced element at an index. Indices start at 1.

(#) :: HasCallStack => [a] -> Number -> a infixl 9 #

Gives the member of a list at a given index. Indices start at 1.

Determines if any proposition in a list is true.

For example, `any([even(n) | n <- [1,2,3]])`

is `True`

, because 2 is even.

Determines if all propositions in a list are true.

For example, `all([even(n) | n <- [2,3,4]])`

is `False`

, because 3 is not even.

Determines if all propositions in a list are false.

For example, `none([odd(n) | n <- [2,3,4]])`

is `False`

, because 3 is odd.

first :: HasCallStack => ([a], Number) -> [a] #

Gives the first members of a list, up to the given number.

last :: HasCallStack => ([a], Number) -> [a] #

Gives the last members of a list, up to the given number.

rest :: HasCallStack => ([a], Number) -> [a] #

Gives all members of a list after the given number.

In general, `xs = first(xs, n) ++ rest(xs, n)`

.

groups :: ([a], Number) -> [[a]] #

Converts a list of elements into a list of smaller lists, each of the given length.

For example, `[ (x, y) | [x, y] <- groups(randomNumbers(42), 2) ]`

.

while :: ([a], a -> Truth) -> [a] #

Gives the longest prefix of a list for which a condition is true.

For example, `while([2,4,5,6], even) = [2,4]`

.

until :: ([a], a -> Truth) -> [a] #

Gives the longest prefix of a list for which a condition is false.

For example, `until([2,4,5,6], odd) = [2,4]`

.

after :: ([a], a -> Truth) -> [a] #

Gives the remaining portion of a list after the longest prefix for which a condition is true.

In general, `xs = while(xs, cond) ++ after(xs, cond)`

.

concatenation :: [[a]] -> [a] #

Gives the concatenation of all of the lists in its input.

transposed :: [[a]] -> [[a]] #

randomNumbers :: Number -> [Number] #

## Instances

Monad IO | |

Functor IO | |

Applicative IO | |

MonadPlus IO | |

Alternative IO | |

PrimBase IO | |

Defined in Control.Monad.Primitive | |

PrimMonad IO | |

MonadRef IO | |

Quasi IO | |

Defined in Language.Haskell.TH.Syntax qReport :: Bool -> String -> IO () qRecover :: IO a -> IO a -> IO a qLookupName :: Bool -> String -> IO (Maybe Name) qReifyFixity :: Name -> IO (Maybe Fixity) qReifyInstances :: Name -> [Type] -> IO [Dec] qReifyRoles :: Name -> IO [Role] qReifyAnnotations :: Data a => AnnLookup -> IO [a] qReifyModule :: Module -> IO ModuleInfo qReifyConStrictness :: Name -> IO [DecidedStrictness] qAddDependentFile :: FilePath -> IO () qAddTempFile :: String -> IO FilePath qAddTopDecls :: [Dec] -> IO () qAddForeignFilePath :: ForeignSrcLang -> String -> IO () qAddModFinalizer :: Q () -> IO () qAddCorePlugin :: String -> IO () qGetQ :: Typeable a => IO (Maybe a) qPutQ :: Typeable a => a -> IO () qIsExtEnabled :: Extension -> IO Bool qExtsEnabled :: IO [Extension] | |

MonadAtomicRef IO | |

Defined in Control.Monad.Ref atomicModifyRef :: Ref IO a -> (a -> (a, b)) -> IO b atomicModifyRef' :: Ref IO a -> (a -> (a, b)) -> IO b | |

MonadBaseControl IO IO | |

Defined in Control.Monad.Trans.Control type StM IO a :: Type | |

Semigroup a => Semigroup (IO a) | |

Monoid a => Monoid (IO a) | |

type PrimState IO | |

Defined in Control.Monad.Primitive type PrimState IO = RealWorld | |

type Ref IO | |

Defined in Control.Monad.Ref type Ref IO = IORef | |

type StM IO a | |

Defined in Control.Monad.Trans.Control type StM IO a = a |