Learn ELIXIR with Real Code Examples

defmodule Counter do
    def run do
        count = 0
        is_dark = false

        update_ui = fn ->
        IO.puts("Counter: #{count}")
        IO.puts("Theme: #{if is_dark, do: \"Dark\", else: \"Light\"}")
        end

        increment = fn ->
        count = count + 1
        update_ui.()
        end

        decrement = fn ->
        count = count - 1
        update_ui.()
        end

        reset = fn ->
        count = 0
        update_ui.()
        end

        toggle_theme = fn ->
        is_dark = !is_dark
        update_ui.()
        end

        # Simulate actions
        update_ui.()
        increment.()
        increment.()
        toggle_theme.()
        decrement.()
        reset.()
    end
end

Counter.run()

Demonstrates a simple counter with theme toggling using Elixir variables and console output.

add = fn a, b -> a + b end
subtract = fn a, b -> a - b end
multiply = fn a, b -> a * b end
divide = fn a, b -> a / b end

IO.puts("Add 5 + 3: #{add.(5,3)}")
IO.puts("Subtract 5 - 3: #{subtract.(5,3)}")
IO.puts("Multiply 5 * 3: #{multiply.(5,3)}")
IO.puts("Divide 6 / 2: #{divide.(6,2)}")

Demonstrates addition, subtraction, multiplication, and division with anonymous functions.

Enum.each(1..15, fn n ->
    IO.puts cond do
        nrem(n, 15) == 0 -> "FizzBuzz"
        nrem(n, 3) == 0 -> "Fizz"
        nrem(n, 5) == 0 -> "Buzz"
        true -> Integer.to_string(n)
    end
end)

Classic FizzBuzz problem using pattern matching and anonymous functions.

factorial = fn
    0 -> 1
    n -> n * factorial.(n - 1)
end

IO.puts("Factorial of 5: #{factorial.(5)}")

Recursive factorial function in Elixir.

fibonacci = fn
    0 -> 0
    1 -> 1
    n -> fibonacci.(n-1) + fibonacci.(n-2)
end

Enum.each(0..9, fn n -> IO.puts(fibonacci.(n)) end)

Recursive Fibonacci sequence generator.

numbers = 1..10
squares = for n <- numbers, rem(n, 2) == 0, do: n * n
IO.inspect(squares)

Using list comprehension to square even numbers.

scores = %{alice: 10, bob: 5, charlie: 12}
high_scores = for {k, v} <- scores, v >= 10, into: %{}, do: {k, v}
IO.inspect(high_scores)

Filtering a map based on value conditions.

add = &(&1 + &2)
IO.puts(add.(3, 7))

Using the capture operator to shorten anonymous functions.

numbers = [1,2,3,4,5]
sum = Enum.reduce(numbers, 0, fn x, acc -> x + acc end)
IO.puts(sum)

Summing a list of numbers using Enum.reduce.