module Basics where
{-| Tons of useful functions that get imported by default.
The following libraries also get imported by default: List, Signal,
Text, Maybe, Time, Graphics.Element, Color, Graphics.Collage.
# Equality
@docs (==), (/=)
# Comparison
These functions only work on `comparable` types. This includes numbers,
characters, strings, lists of comparable things, and tuples of comparable
things. Note that tuples with 7 or more elements are not comparable; why
are your tuples so big?
@docs (<), (>), (<=), (>=), max, min, Order, compare
# Booleans
@docs not, (&&), (||), xor, otherwise
# Mathematics
@docs (+), (-), (*), (/), (^), (//), rem, (%), negate, abs, sqrt, clamp, logBase, e
# Trigonometry
@docs pi, cos, sin, tan, acos, asin, atan, atan2
# Number Conversions
@docs round, floor, ceiling, truncate, toFloat
# Angle Conversions
All angle conversions result in “standard Elm angles”
which happen to be radians.
@docs degrees, radians, turns
# Polar Coordinates
@docs toPolar, fromPolar
# Floating Point Checks
@docs isNaN, isInfinite
# Strings and Lists
@docs toString, (++)
# Tuples
@docs fst, snd
# Higher-Order Helpers
@docs identity, always, (<|), (|>), (<<), (>>), flip, curry, uncurry
-}
import Native.Basics
import Native.Ports
import Native.Show
import Native.Utils
import Native.Runtime
{-| Convert radians to standard Elm angles (radians). -}
radians : Float -> Float
radians t = t
{-| Convert degrees to standard Elm angles (radians). -}
degrees : Float -> Float
degrees = Native.Basics.degrees
{-| Convert turns to standard Elm angles (radians).
One turn is equal to 360°.
-}
turns : Float -> Float
turns = Native.Basics.turns
{-| Convert polar coordinates (r,θ) to cartesian coordinates (x,y). -}
fromPolar : (Float,Float) -> (Float,Float)
fromPolar = Native.Basics.fromPolar
{-| Convert cartesian coordinates (x,y) to polar coordinates (r,θ). -}
toPolar : (Float,Float) -> (Float,Float)
toPolar = Native.Basics.toPolar
(+) : number -> number -> number
(+) = Native.Basics.add
(-) : number -> number -> number
(-) = Native.Basics.sub
(*) : number -> number -> number
(*) = Native.Basics.mul
{-| Floating point division. -}
(/) : Float -> Float -> Float
(/) = Native.Basics.floatDiv
infixl 6 +
infixl 6 -
infixl 7 *
infixl 7 /
infixl 8 ^
infixl 7 //
infixl 7 %
infixl 7 `rem`
{-| Integer division. The remainder is discarded. -}
(//) : Int -> Int -> Int
(//) = Native.Basics.div
{-| Find the remainder after dividing one number by another.
7 `rem` 2 == 1
-1 `rem` 4 == -1
-}
rem : Int -> Int -> Int
rem = Native.Basics.rem
{-| Perform [modular arithmetic](http://en.wikipedia.org/wiki/Modular_arithmetic).
7 % 2 == 1
-1 % 4 == 3
-}
(%) : Int -> Int -> Int
(%) = Native.Basics.mod
{-| Exponentiation
3^2 == 9`
-}
(^) : number -> number -> number
(^) = Native.Basics.exp
cos : Float -> Float
cos = Native.Basics.cos
sin : Float -> Float
sin = Native.Basics.sin
tan : Float -> Float
tan = Native.Basics.tan
acos : Float -> Float
acos = Native.Basics.acos
asin : Float -> Float
asin = Native.Basics.asin
{-| You probably do not want to use this. It takes `(y/x)` as the
argument, so there is no way to know whether the negative signs comes from
the `y` or `x`. Thus, the resulting angle is always between π/2 and -π/2
(in quadrants I and IV). You probably want to use `atan2` instead.
-}
atan : Float -> Float
atan = Native.Basics.atan
{-| This helps you find the angle of a cartesian coordinate.
You will almost certainly want to use this instead of `atan`.
So `atan2 y x` computes *atan(y/x)* but also keeps track of which
quadrant the angle should really be in. The result will be between
π and -π, giving you the full range of angles.
-}
atan2 : Float -> Float -> Float
atan2 = Native.Basics.atan2
{-| Take the square root of a number. -}
sqrt : Float -> Float
sqrt = Native.Basics.sqrt
{-| Negate a number.
negate 42 == -42
negate -42 == 42
negate 0 == 0
-}
negate : number -> number
negate = Native.Basics.negate
{-| Take the absolute value of a number. -}
abs : number -> number
abs = Native.Basics.abs
{-| Calculate the logarithm of a number with a given base.
logBase 10 100 == 2
logBase 2 256 == 8
-}
logBase : Float -> Float -> Float
logBase = Native.Basics.logBase
{-| Clamps a number within a given range. With the expression
`clamp 100 200 x` the results are as follows:
100 if x < 100
x if 100 <= x < 200
200 if 200 <= x
-}
clamp : number -> number -> number -> number
clamp = Native.Basics.clamp
{-| An approximation of pi. -}
pi : Float
pi = Native.Basics.pi
{-| An approximation of e. -}
e : Float
e = Native.Basics.e
(==) : a -> a -> Bool
(==) = Native.Basics.eq
(/=) : a -> a -> Bool
(/=) = Native.Basics.neq
(<) : comparable -> comparable -> Bool
(<) = Native.Basics.lt
(>) : comparable -> comparable -> Bool
(>) = Native.Basics.gt
(<=) : comparable -> comparable -> Bool
(<=) = Native.Basics.le
(>=) : comparable -> comparable -> Bool
(>=) = Native.Basics.ge
infix 4 ==
infix 4 /=
infix 4 <
infix 4 >
infix 4 <=
infix 4 >=
{-| Compare any two comparable values. Comparable values include `String`, `Char`,
`Int`, `Float`, `Time`, or a list or tuple containing comparable values.
These are also the only values that work as `Dict` keys or `Set` members.
-}
compare : comparable -> comparable -> Order
compare = Native.Basics.compare
{-| Represents the relative ordering of two things.
The relations are less than, equal to, and greater than.
-}
type Order = LT | EQ | GT
{-| Find the smaller of two comparables. -}
min : comparable -> comparable -> comparable
min = Native.Basics.min
{-| Find the larger of two comparables. -}
max : comparable -> comparable -> comparable
max = Native.Basics.max
{-| The logical AND operator. `True` if both inputs are `True`.
This operator short-circuits to `False` if the first argument is `False`.
-}
(&&) : Bool -> Bool -> Bool
(&&) = Native.Basics.and
{-| The logical OR operator. `True` if one or both inputs are `True`.
This operator short-circuits to `True` if the first argument is True.
-}
(||) : Bool -> Bool -> Bool
(||) = Native.Basics.or
infixr 3 &&
infixr 2 ||
{-| The exclusive-or operator. `True` if exactly one input is `True`. -}
xor : Bool -> Bool -> Bool
xor = Native.Basics.xor
{-| Negate a boolean value.
not True == False
not False == True
-}
not : Bool -> Bool
not = Native.Basics.not
{-| Equal to `True`. Useful as the last case of a multi-way-if. -}
otherwise : Bool
otherwise = True
-- Conversions
{-| Round a number to the nearest integer. -}
round : Float -> Int
round = Native.Basics.round
{-| Truncate a number, rounding towards zero. -}
truncate : Float -> Int
truncate = Native.Basics.truncate
{-| Floor function, rounding down. -}
floor : Float -> Int
floor = Native.Basics.floor
{-| Ceiling function, rounding up. -}
ceiling : Float -> Int
ceiling = Native.Basics.ceiling
{-| Convert an integer into a float. -}
toFloat : Int -> Float
toFloat = Native.Basics.toFloat
{- | Determine whether a float is an undefined or unrepresentable number.
NaN stands for *not a number* and it is [a standardized part of floating point
numbers](http://en.wikipedia.org/wiki/NaN).
isNaN (0/0) == True
isNaN (sqrt -1) == True
isNaN (1/0) == False -- infinity is a number
isNaN 1 == False
-}
isNaN : Float -> Bool
isNaN = Native.Basics.isNaN
{- | Determine whether a float is positive or negative infinity.
isInfinite (0/0) == False
isInfinite (sqrt -1) == False
isInfinite (1/0) == True
isInfinite 1 == False
Notice that NaN is not infinite! For float `n` to be finite implies that
`not (isInfinite n || isNaN n)` evaluates to `True`.
-}
isInfinite : Float -> Bool
isInfinite = Native.Basics.isInfinite
{-| Turn any kind of value into a string.
toString 42 == "42"
toString [1,2] == "[1,2]"
-}
toString : a -> String
toString = Native.Show.toString
{-| Put two appendable things together. This includes strings, lists, and text.
"hello" ++ "world" == "helloworld"
[1,1,2] ++ [3,5,8] == [1,1,2,3,5,8]
-}
(++) : appendable -> appendable -> appendable
(++) = Native.Utils.append
infixr 5 ++
-- Function Helpers
{-| Function composition, passing results along in the suggested direction. For
example, the following code checks if the square root of a number is odd:
not << isEven << sqrt
You can think of this operator as equivalent to the following:
(g << f) == (\x -> g (f x))
So our example expands out to something like this:
\n -> not (isEven (sqrt n))
-}
(<<) : (b -> c) -> (a -> b) -> (a -> c)
(<<) g f x = g (f x)
{-| Function composition, passing results along in the suggested direction. For
example, the following code checks if the square root of a number is odd:
sqrt >> isEven >> not
This direction of function composition seems less pleasant than `(<<)` which
reads nicely in expressions like: `filter (not << isRegistered) students`
-}
(>>) : (a -> b) -> (b -> c) -> (a -> c)
(>>) f g x = g (f x)
{-| Forward function application `x |> f == f x`. This function is useful
for avoiding parenthesis and writing code in a more natural way.
Consider the following code to create a pentagon:
scale 2 (move (10,10) (filled blue (ngon 5 30)))
This can also be written as:
ngon 5 30 |> filled blue
|> move (10,10)
|> scale 2
-}
(|>) : a -> (a -> b) -> b
x |> f = f x
{-| Backward function application `f <| x == f x`. This function is useful for
avoiding parenthesis. Consider the following code to create a text element:
text (monospace (toText "code"))
This can also be written as:
text . monospace <| toText "code"
-}
(<|) : (a -> b) -> a -> b
f <| x = f x
infixr 9 <<
infixl 9 >>
infixr 0 <|
infixl 0 |>
{-| Given a value, returns exactly the same value. This is called
[the identity function](http://en.wikipedia.org/wiki/Identity_function).
-}
identity : a -> a
identity x = x
{-| Create a [constant function](http://en.wikipedia.org/wiki/Constant_function),
a function that *always* returns the same value regardless of what input you give.
It is defined as:
always a b = a
It totally ignores the second argument, so `always 42` is a function that always
returns 42. When you are dealing with higher-order functions, this comes in
handy more often than you might expect. For example, creating a zeroed out list
of length ten would be:
map (always 0) [0..9]
-}
always : a -> b -> a
always a _ = a
{-| Given a 2-tuple, returns the first value. -}
fst : (a,b) -> a
fst (a,_) = a
{-| Given a 2-tuple, returns the second value. -}
snd : (a,b) -> b
snd (_,b) = b
{-| Flip the order of the first two arguments to a function. -}
flip : (a -> b -> c) -> (b -> a -> c)
flip f b a = f a b
{-| Change how arguments are passed to a function.
This splits paired arguments into two separate arguments.
-}
curry : ((a,b) -> c) -> a -> b -> c
curry f a b = f (a,b)
{-| Change how arguments are passed to a function.
This combines two arguments into a single pair.
-}
uncurry : (a -> b -> c) -> (a,b) -> c
uncurry f (a,b) = f a b