Converting OOP conepts to Elixir

Given 3 java classes, Container extends Box and Box extends Dimension and I am trying to port them in Elixir
and it is extremly counterintuitive.

public class Dimension {
  protected int width; // x
  protected int depth; // y
  protected int height; // z
  protected long volume;
  protected final String name;

  public Dimension() {

  public Dimension(String name, int w, int d, int h) { = name;

    this.depth = d;
    this.width = w;
    this.height = h;


  protected void calculateVolume() {
    this.volume = ((long)depth) * ((long)width) * ((long)height);
public class Box extends Dimension {
  final int weight;

  public Box(int w, int d, int h, int weight) {
    super(w, d, h);

    this.weight = weight;
public class Container extends Box {
  private int stackWeight = 0;
  private int stackHeight = 0;
  private ArrayList<Level> levels = new ArrayList<>();

  public Container(Container container) {
    super(container.getName(), container.getWidth(), container.getDepth(), container.getHeight(), container.getWeight());

And I am heading to this direction

defmodule Foo.Dimension do
  alias Foo.{Box, Dimension}
  defstruct [:name, :width, :depth, :height, :volume]

  defmacro __using__(_opts) do
    quote do
      @spec calculate_volume(%Dimension{}) :: %Dimension{}
      def calculate_volume(%Dimension{} = dimension) do
        volume = dimension.depth * dimension.width * dimension.height
        %{dimension | volume: volume}
defmodule Foo.Box do
  use Foo.Dimension
  alias Foo.{Box, Dimension}
  @enforce_keys [:weight]
  defstruct [:name, :weight, :width, :depth, :height, :volume]
defmodule Foo.Container do
  use Foo.Dimension
  alias Foo.{Container, Dimension}
  defstruct [:volume, stack_weight: 0, stack_height: 0, width: 0, depth: 0, height: 0, weight: 0...]

The problems I am having are:

  1. I have to repeat the base struct [:name, :width, :depth, :height, :volume] from Dimension all the way up to the top extender(Container)
  2. What is the best way to deal with the Dimension constructor that calls calculateVolume()? If extender(Box or Container) do a super() call, how does it initiate :volume? Do I have to
  %Container{...} |> Container.calculate_volume()
  %Box{...} |> Box.calculate_volume()
  1. I am not sure if it is a good idea to mimic the inheritance like that in Foo.Dimension by using defmacro __using__(_) do

Just forget about inheritance and simply implement the Container.

1 Like

This is an approach doomed to frustration. OOP and FP usually take fundamentally different approaches to thinking about problems. Break your problem down into simple data, and then solve the problem by transforming that data. Throw out notions of objects, definitely throw out notions of inheritance.


Hint: Have a look at Protocols :slight_smile:

1 Like

Probably better to forget about this particular implementation and go back to the source algorithm: An Efficient Algorithm for 3D Rectangular Box Packing.


  • Number of different sized Boxes: N
  • Width of nth box: an
  • Depth of nth box: bn
  • Height of nth box: cn
  • Number of nth box: kn


  • O1: The volume of container
  • O2: The used space (The volume of all boxes placed)
  • O3: The wasted space
  • O4: The running time

This can start you off:

defmodule Dimension do
  defstruct [:width, :depth, :height, :volume, :name]

  def volume(w, d, h) do
    w * d * h

  def new(name, w, d, h) do
      name: name,
      width: w,
      height: h,
      volume: volume(d, w, h)

Sample usage (this gives you a new instance of the struct every time):

d ="something", 2, 3, 4)

You can enrich this starter module with guards in the functions – like when is_integer(w) for example.

NOTE: This module does NOT work on an encapsulated data structure like in Java!

It’s simply an utility module to work with the structure. Functions there are not methods for a singular instance. Have that huge difference in mind.

As other said, forget about direct mapping from OOP to FP – it does not exist. Think about your data and make transformation functions.

1 Like