Converting OOP conepts to Elixir

chungwong

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.

# https://github.com/skjolber/3d-bin-container-packing/blob/master/src/main/java/com/github/skjolberg/packing/Box.java
public class Dimension {
  protected int width; // x
  protected int depth; // y
  protected int height; // z
  protected long volume;
  protected final String name;

  public Dimension() {
    this(null);
  }

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

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

    calculateVolume();
  }

  protected void calculateVolume() {
    this.volume = ((long)depth) * ((long)width) * ((long)height);
  }
}

# https://github.com/skjolber/3d-bin-container-packing/blob/master/src/main/java/com/github/skjolberg/packing/Dimension.java
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;
  }
}

# https://github.com/skjolber/3d-bin-container-packing/blob/master/src/main/java/com/github/skjolberg/packing/Container.java
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}
      end
      ....
    end
  end
end

defmodule Foo.Box do
  use Foo.Dimension
  alias Foo.{Box, Dimension}
  @enforce_keys [:weight]
  defstruct [:name, :weight, :width, :depth, :height, :volume]
end

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...]
end

The problems I am having are:

I have to repeat the base struct [:name, :width, :depth, :height, :volume] from Dimension all the way up to the top extender(Container)
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()

I am not sure if it is a good idea to mimic the inheritance like that in Foo.Dimension by using defmacro __using__(_) do

5 comments

#oop

0 1207 5

2019-05-20 15:46:41 UTC

Showing Posts 1 to 5

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

NobbZ

Just forget about inheritance and simply implement the Container.

Post #1

benwilson512

Author of Craft GraphQL APIs in Elixir with Absinthe

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.

Post #2

l00ker

Hint: Have a look at Protocols

Post #3

peerreynders

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

Inputs

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

Outputs

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

Post #4

dimitarvp

This can start you off:

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

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

  def new(name, w, d, h) do
    %__MODULE__{
      name: name,
      width: w,
      height: h,
      volume: volume(d, w, h)
    }
  end
end

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

d = Dimension.new("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.

Post #5

— All posts loaded —