0Pricing
Elixir & Phoenix: Scalable Backend Development · Lesson

Basic Data Types and Operators

Explore fundamental Elixir data types such as atoms, lists, tuples, maps, and learn how to use basic operators.

Basic Data Types and Operators is a free Elixir & Phoenix: Scalable Backend Development lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Elixir & Phoenix: Scalable Backend Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Data Types & Operators Intro

Every program rests on data types (what you can store) and operators (the symbols that act on it). Let us meet Elixir core.

Numbers: Integers & Floats

Elixir has two number types: integers like 42 and floats like 3.14. Standard math works on both, as this snippet shows.

defmodule NumbersDemo do
  def run() do
    integer_num = 42
    float_num = 3.14159

    IO.puts "Integer: #{integer_num}"
    IO.puts "Float: #{float_num}"
    IO.puts "Sum: #{integer_num + 10.0}"
  end
end

NumbersDemo.run()

Booleans: True, False, Nil

Truth values are true and false. Note nil for "no value" — and that both false and nil are falsy; everything else is truthy.

defmodule BooleansDemo do
  def run() do
    is_active = true
    has_error = false
    no_value = nil

    IO.puts "Is Active? #{is_active}"
    IO.puts "Has Error? #{has_error}"
    IO.puts "No Value? #{no_value}"

    if no_value do
      IO.puts "This won't print."
    else
      IO.puts "nil is falsy!"
    end
  end
end

BooleansDemo.run()

Atoms: Unique Identifiers

An atom is a constant whose name is its own value, like :ok. They are fast to compare and ideal as status codes and map keys.

defmodule AtomsDemo do
  def run() do
    status = :ok
    type = :user

    IO.puts "Current status: #{status}"
    IO.puts "User type: #{type}"

    if status == :ok do
      IO.puts "Operation successful!"
    end
  end
end

AtomsDemo.run()

Strings: Text Data

An Elixir string is a UTF-8 binary in double quotes, so it handles any language. Join strings with the <> operator.

defmodule StringsDemo do
  def run() do
    greeting = "Hello"
    name = "CoddyKit"
    message = greeting <> ", " <> name <> "!"

    IO.puts message
    IO.puts "String length: " <> to_string(String.length(message))
  end
end

StringsDemo.run()

Lists: Ordered Collections

A list is an ordered, square-bracketed collection that can mix types. It is the functional workhorse, fast to prepend to at the head.

defmodule ListsDemo do
  def run() do
    my_list = [1, 2, 3, :hello, "world"]
    another_list = [4, 5]

    IO.puts "Original list: " <> inspect(my_list)
    IO.puts "Concatenated list: " <> inspect(my_list ++ another_list)
    IO.puts "Head of list: " <> inspect(hd(my_list))
    IO.puts "Tail of list: " <> inspect(tl(my_list))
  end
end

ListsDemo.run()

Tuples: Fixed-Size Collections

A tuple is a fixed-size collection in curly braces. You see it everywhere for grouped returns like {:ok, result} or {:error, reason}.

defmodule TuplesDemo do
  def run() do
    person_info = {"Alice", 30, :female}
    result_tuple = {:ok, "Data fetched"}

    IO.puts "Person: " <> inspect(person_info)
    IO.puts "Result: " <> inspect(result_tuple)

    # Accessing elements (0-indexed)
    IO.puts "Name: " <> elem(person_info, 0)
  end
end

TuplesDemo.run()

Maps: Key-Value Pairs

A map holds key-value pairs in %{} — usually atom keys for speed. Reach for it whenever you model structured records or config.

defmodule MapsDemo do
  def run() do
    user = %{name: "Bob", age: 25, city: "New York"}

    IO.puts "User: " <> inspect(user)
    IO.puts "User's name: #{user.name}"

    # Updating a map
    updated_user = %{user | age: 26}
    IO.puts "Updated age: #{updated_user.age}"
  end
end

MapsDemo.run()

Arithmetic Operators

Elixir gives you the usual arithmetic operators, plus div and rem for integers. Heads up: / always returns a float.

defmodule ArithmeticDemo do
  def run() do
    IO.puts "5 + 3 = #{5 + 3}"
    IO.puts "10 - 4 = #{10 - 4}"
    IO.puts "6 * 7 = #{6 * 7}"
    IO.puts "10 / 3 = #{10 / 3}"  # Float division
    IO.puts "10 div 3 = #{10 div 3}" # Integer division
    IO.puts "10 rem 3 = #{10 rem 3}" # Remainder
  end
end

ArithmeticDemo.run()

Comparison Operators

Comparison operators return a boolean. Use == for value equality, but === when type matters too — 1 === 1.0 is false.

defmodule ComparisonDemo do
  def run() do
    IO.puts "5 == 5: #{5 == 5}"
    IO.puts "5 != 10: #{5 != 10}"
    IO.puts "5 < 10: #{5 < 10}"
    IO.puts "10 >= 10: #{10 >= 10}"
    IO.puts "1 == 1.0: #{1 == 1.0}" # True (value equality)
    IO.puts "1 === 1.0: #{1 === 1.0}" # False (type strictness)
  end
end

ComparisonDemo.run()

Check Your Understanding

Consider the following Elixir code snippet:

result = 10 div 3
status = :ok
message = "Value is #{result}"
comparison = (result > 3) == true

IO.puts "#{message}, Status: #{status}, Comparison: #{comparison}"

What will be the final output of this code?

Check Your Understanding (Revised)

Consider the following Elixir code snippet:

result = 10 div 3
status = :ok
message = "Value is #{result}"
comparison = (result > 3)

IO.puts "#{message}, Status: #{status}, Comparison: #{comparison}"

What will be the final output of this code?

Recap: Data Types & Operators

Recap: integers and floats, booleans plus nil, atoms, strings, lists, tuples, maps, and the operators that drive them. These are your Elixir foundation.

Frequently asked questions

Is the “Basic Data Types and Operators” lesson free?

Yes — the full text of “Basic Data Types and Operators” is free to read here on the web, and the Elixir & Phoenix: Scalable Backend Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Elixir & Phoenix: Scalable Backend Development course, upgrade to CoddyKit PRO.

What will I learn in “Basic Data Types and Operators”?

Explore fundamental Elixir data types such as atoms, lists, tuples, maps, and learn how to use basic operators. You practise Elixir & Phoenix: Scalable Backend Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Elixir & Phoenix: Scalable Backend Development?

No prior experience is required. Elixir & Phoenix: Scalable Backend Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Basic Data Types and Operators” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Elixir & Phoenix: Scalable Backend Development lesson?

Yes. Every Elixir & Phoenix: Scalable Backend Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Elixir Language
  2. Basic Data Types and Operators
  3. Pattern Matching and Control Flow
  4. Strings, Binaries & Sigils in Elixir
← Back to Elixir & Phoenix: Scalable Backend Development