local F = require 'functional'

-- Basic examples
local square = F.lambda('|x| x * x')
local numbers = {1, 2, 3, 4, 5}
local squared = F.map(square, ipairs, numbers)
print(table.concat(squared, ", ")) -- 1, 4, 9, 16, 25

-- Create an immutable tuple
local t = F.tuple(1, 2, 3)

-- Create an immutable list
local list = F.list(1, 2, 3, 4, 5)

-- Access elements
local first = F.head(list)  -- 1
local rest = F.tail(list)   -- list(2, 3, 4, 5)

-- Prepend an element (non-destructive)
local new_list = F.cons(0, list)  -- list(0, 1, 2, 3, 4, 5)

-- Check if a list is empty
if not F.is_empty(list) then
    -- Process list
end

-- Take and drop
local first_three = F.take(3, list)  -- list(1, 2, 3)
local last_two = F.drop(3, list)     -- list(4, 5)

-- Basic value matching
local result = F.match(value, {
    [1] = function() return "one" end,
    [5] = function() return "five" end,
    [F.otherwise] = function() return "other" end
})

-- Type-based matching
local description = F.match(value, {
    [F.is_string] = function(x) return "String: " .. x end,
    [F.is_number] = function(x) return "Number: " .. x end,
    [F.is_table] = function(x) return "Table with " .. #x .. " items" end,
    [F.otherwise] = function() return "Unknown type" end
})

-- Pattern matching with guards
local category = F.match(num, {
    [F.when(function(x) return x < 0 end)] = function() return "negative" end,
    [F.when(function(x) return x == 0 end)] = function() return "zero" end,
    [F.when(function(x) return x > 0 end)] = function() return "positive" end
})

-- Create a processing pipeline
local add1 = function(x) return x + 1 end
local double = function(x) return x * 2 end
local square = function(x) return x * x end

-- Create a pipeline of functions (functional style)
local pipeline = F.pipe(add1, double, square)
local result = pipeline(5)  -- ((5 + 1) * 2)^2 = 144

-- Process a value through multiple transformations (function form)
local total = F.pipe_val(data,
    transform1,
    transform2,
    transform3
)

-- Cleaner array syntax for chaining operations
local result = F.pipe_with(initial_value, {
    operation1,
    operation2,
    operation3
})

-- Method chaining approach (closer to Elixir's |> or F#'s |> pipe operators)
local pipeline = F.chain(add1)
    :add(double)
    :add(square)
local fn = pipeline:build()
local result = fn(5)  -- ((5 + 1) * 2)^2 = 144

-- Process a value directly through a method chain
local result = F.chain_val(5)
    :apply(add1)    -- 6
    :apply(double)  -- 12
    :apply(square)  -- 144
    :value()

-- Create Maybe values
local just_value = F.just(42)
local nothing = F.nothing()

-- Check type
if F.is_just(result) then
    -- Process the value
    local value = F.from_just(result)
end

-- Map over a Maybe (safely)
local doubled = F.maybe_map(function(x) return x * 2 end, maybe_value)

-- Chain operations that might fail
local root = F.pipe_val(F.just(value),
    function(m) return F.maybe_bind(safe_division, m) end,
    function(m) return F.maybe_bind(safe_square_root, m) end
)

-- Provide a default for Nothing
local safe_result = F.maybe_default(0, maybe_value)