module Main where
foreign import foreign_ :: Int
foreign__ :: Int
foreign__ = foreign_
const :: forall a b. a -> b -> a
const x _ = x
infixl 5 const as +
infixl 5 const as -
alwaysAlwaysTrue :: forall a. a -> a -> Boolean
alwaysAlwaysTrue _ _ = true
infixl 5 alwaysAlwaysTrue as <=
identity :: forall a. a -> a
identity a = a
flip :: forall a b c. (a -> b -> c) -> b -> a -> c
flip f a b = f b a
data Tuple a b = Tuple a b
tuple :: forall a b. a -> b -> Tuple a b
tuple a b = Tuple a b
type Pair a b = { a :: a, b :: b }
addPair :: Pair Int Int -> Int
addPair pair = pair.a + pair.b
add5 :: Int -> Int
add5 a = a + 5
add5Point1 :: Number -> Number
add5Point1 a = a + 5.1
newPair :: forall a b. a -> b -> Pair a b
newPair a b = { a, b }
booleans :: Array Boolean
booleans = [true, false]
string :: String
string = "..."
letAdd5 :: Int -> Int
letAdd5 = let f x = x + 5 in f
whereAdd5 :: Int -> Int
whereAdd5 = f
where
f x = x + 5
customIncrement :: Int -> Int
customIncrement = case _ of
0 -> 0
n -> n + 1
constInt :: forall a. Int -> a -> Int
constInt 0 _ = 1
constInt a _ = a
alwaysTrue :: Boolean -> Boolean
alwaysTrue = case _ of
false -> true
true -> true
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
applyN :: forall a. (a -> a) -> Int -> a -> a
applyN f = go
where
go n acc
| n <= 0 = acc
| true = go (n - 1) (f acc)
addTuples :: Tuple Int Int -> Tuple Int Int -> Tuple Int Int
addTuples (Tuple a b) (Tuple c d) = Tuple (a + c) (b + d)
ex :: Char
ex = 'x'
complexCase :: { x :: Int, y :: Array Int, z :: Char } -> Int
complexCase = case _ of
{ x: 1, y: [], z: z } -> 1
{ x: x, y: [1, 2, yyy @ yy], z: 'z' } -> x + 1 + 2 + yy + yyy
_ -> 0
newtype Color = Color String
red :: Color
red = Color "red"
class Inspect a where
inspect :: a -> String
data Maybe a = Just a | Nothing
maybe :: Maybe Int
maybe = Just 1
incrementA :: forall r. { a :: Int | r } -> { a :: Int | r }
incrementA o = o { a = o.a + 1 }