Initialising structs and incrementing value for each new struct

kouluelixir

I am a beginner making a code with module. Employee module has a struct and a function. Employees have names, id’s, salaries and jobs. I have gotten updating jobs and salaries to work.

I still need for the employee id to update for each new employee. I also want to be able to assign a first and last name for each new employee. I tried to do that following this: https://inquisitivedeveloper.com/lwm-elixir-18/ (‘Packaging Struct Data and Functions’). But for some reason, it didn’t work, even if I copied their code.

Is this possible? Thank you in advance.

defmodule Employee do

    defstruct firstName: "", lastName: "", id: 0, salary: 0, job: :none

    def new() do

        %Employee{}

    end

    def promote(employee) do

        case employee.job do

            :none -> employee = %{employee | job: :coder, salary: 2000}

            :coder -> employee = %{employee | job: :designer, salary: 4000}

            :designer -> employee = %{employee | job: :manager, salary: 6000}

            :manager -> employee = %{employee | job: :ceo, salary: 8000}

        end

    end

	def increment_id(employee) do
		%Employee{employee | id: employee.id + 1}
	end
end

employee = Employee.new("John", "Smith")
IO.puts("Employee name: #{employee.firstName} #{employee.lastName}. ID: #{employee.id}.
Job and salary: #{employee.job}, #{employee.salary}")


employee = Employee.promote(employee)
IO.puts("Employee name: #{employee.firstName} #{employee.lastName}. ID: #{employee.id}.
Job and salary: #{employee.job}, #{employee.salary}")

employee = Employee.promote(employee)
IO.puts("Employee name: #{employee.firstName} #{employee.lastName}. ID: #{employee.id}.
Job and salary: #{employee.job}, #{employee.salary}")

employee = Employee.demote(employee)
IO.puts("Employee name: #{employee.firstName} #{employee.lastName}. ID: #{employee.id}.
Job and salary: #{employee.job}, #{employee.salary}")


employee2 = Employee.new("Jane", "Doe")
IO.puts("Employee name: #{employee2.firstName} #{employee2.lastName}. ID: #{employee2.id}.
Job and salary: #{employee2.job}, #{employee2.salary}")

8 comments

#data-structures #structs #modules

0 1593 8

2021-10-15 18:12:34 UTC

Showing Posts 1 to 8

Show Best Posts
Show All (oldest first)
Show All (newest first)

Matsa59

Hello, let’s explain step by step

employee = Employee.new("John", "Smith")

This line we call the function new/2 in a module called Employee. In your case this function doesn’t exist. You defined the function new/0 that doesn’t take any parameter.

So let’s update our code to have the right function:


defmodule Employee do
  defstruct first_name: "", last_name: "", id: 0, salary: 0, job: :none

  # Obviously you can call parameter without _var
  # I just add it to clarify the code in the function
  def new(first_name_var, last_name_var) do
    %Employee{first_name: first_name_var, last_name: last_name_var}
  end

  def promote(employee) do
    # ...
  end

  def increment_id(employee) do
    # ...
  end
end

in Elixir only modules names are in camel case, otherwise it’s in kebab case that’s why I changed firstName to first_name.

If you have any other question just ask

Have a great day

edit : Try to create a function display/1 that take an employee as parameter. Then simply call Employee.display(employee) to execute the IO.puts/1
The main objectives of Modules is to reduce the code size meaning when you can factor something, create a function.

Post #1

kouluelixir

Thank you, I didn’t know about the camel/kebab case. How would you go about incrementing the id for each created employee? Is it even possible with Elixir?

Post #2

Matsa59

Yeah, you can use Agent or GenServer to hold the value.
Or simply use the previous employee’s id and increment it by one.

employee1 = Employee.new("John", "Doe")
employee2 = Employee.new("Jane", "Doe")

# So here employee1.id == 0 and employee2.id == 0
employee2 = %{employee2 | id: employee1.id + 1}

Often this will be enough

Or using an GenServer

defmodule MyGenServer do
  use GenServer

  def start_link(state) do
    GenServer.start_link(MyGenServer, state, name: :my_gen_server)
  end
  
  # Here state is the 2nd param of `GenServer.start_link/3`
  def init(state), do: {:ok, state}

  def incr do
    # Here we use the name of the GenServer
    GenServer.call(:my_gen_server, :incr)
  end

  # server side, access through GenServer.call or GenServer.cast

  def handle_call(:incr, _from, state) do
    {:reply, state, state + 1}
  end
end

# code to use the GenServer that will manage our id incr

MyGenServer.start_link(0) #  {:ok, pid} =>
# We dont really care of the pid here because we named our GenServer
# A named GenServer is accessible using its name instead of its PID
MyGenServer.inc() # 0
MyGenServer.inc() # 1
MyGenServer.inc() # 2
MyGenServer.inc() # 3

So update your Employee module to have

defmodule Employee do
  defstruct first_name: "", last_name: "", id: nil, salary: 0, job: :none

  # Obviously you can call parameter without _var
  # I just add it to clarify the code in the function
  def new(first_name_var, last_name_var) do
    %Employee{
      first_name: first_name_var, 
      last_name: last_name_var, 
      id: MyGenServer.inc()
    }
  end

You can read more about GenServer here

Post #3

dom

There’s a nice tutorial on Agent: https://elixir-lang.org/getting-started/mix-otp/agent.html

More typically you’d just use a DB. If this is for testing or playing around, you can also use :erlang.unique_integer.

Post #4

Matsa59

Yeah of course, I supposed he wants to do something that increment one by one

Post #5

axelson

Scenic Core Team

I would like to note that for a production system you’d probably want to generate the incrementing ids in the database.

Post #6

Matsa59

Yes, but he didn’t talk about long term storage. And also the GenServer could also initialized its value for example (for hazardous old database lmao)

Post #7