Operators

let addition = 5 + 3      -- 8
let subtraction = 10 - 4  -- 6
let multiply = 6 * 7      -- 42
let divide = 15 / 3       -- 5.0
let intDiv = 10 // 3      -- 3
let modulo = 17 % 5       -- 2
let power = 2 ^ 10        -- 1024
let negative = -42        -- -42 (negation)

power

let floatDiv = 10 / 3     -- Float division: 3.333...
let intDiv = 10 // 3      -- Integer division: 3

(floatDiv, intDiv)

let x = 1 + 2.5    -- Float: 3.5
let y = 3 * 1.5    -- Float: 4.5

x + y  -- 8.0

let eq = 5 == 5     -- True
let neq = 5 != 6    -- True
let lt = 3 < 5      -- True
let gt = 5 > 3      -- True
let lte = 3 <= 3    -- True
let gte = 5 >= 4    -- True

(eq, neq, lt, gt, lte, gte)

-- And (both must be True)
let and1 = True && True   -- True
let and2 = True && False  -- False

-- Or (at least one must be True)
let or1 = True || False   -- True
let or2 = False || False  -- False

-- Not (negation)
let not1 = not True       -- False
let not2 = not False      -- True
let not3 = not (1 > 2)    -- True
let not4 = not not True   -- True (double negation)

(and1, or1, not1, not3)

-- False && ... returns False immediately without evaluating the right side
let result = False && True
result  -- False

-- Concatenation
"Hello, " ++ "World!"  -- "Hello, World!"

-- Cons (prepend element)
let consed1 = 1 :: [2, 3]        -- [1, 2, 3]
let consed2 = 1 :: (2 :: [])     -- [1, 2]

-- Note: 1 :: 2 :: [] without parentheses throws an error
-- because :: is left-associative, parsing as (1 :: 2) :: []

-- Concatenation
let joined = [1, 2] ++ [3, 4]    -- [1, 2, 3, 4]

joined

fn double : Int -> Int
fn double x = x * 2

fn addOne : Int -> Int
fn addOne x = x + 1

-- Forward pipe
5 |> double           -- Same as: double 5 = 10

-- Pipeline example
[1, 2, 3, 4, 5]
    |> filter (|x| x > 2)
    |> map (|x| x * 2)
    -- [6, 8, 10]

-- Forward composition (f first, then g)
let addOne = |x: Int| x + 1
let double = |x: Int| x * 2
let addThenDouble = addOne >> double

addThenDouble 5   -- 12 (5 + 1 = 6, 6 * 2 = 12)

-- Backward composition (g first, then f)
let addOne = |x: Int| x + 1
let double = |x: Int| x * 2
let doubleThenAdd = addOne << double

doubleThenAdd 5   -- 11 (5 * 2 = 10, 10 + 1 = 11)