# Design problem with three similar structs

I am working on the Tensor library. This adds three modules to your project: `Vector`, `Matrix` and `Tensor`.

As you may or may not know, a Vector is just a one-dimensional Tensor, and a Matrix is a two-dimensional Tensor. Therefore, the `Vector` and `Matrix` modules contain some extra functions that only make sense when working with these low-dimensional structures(`from_list` only makes sense for Vectors, `rotate_clockwise` only makes sense for Matrices, etc.), but besides that, they delegate many functions to the `Tensor` module.

Right now, there is only one Struct being manipulated by all three modules: `%Tensor{dimensions: [], contents: %{}, identity: 0}`. A Vector can be pattern-matched as follows: `vector = %Tensor{dimensions: [length]}`. A Matrix can be pattern-matched as follows: `matrix = %Tensor{dimensions: [height, width]}`.

Needless to say, this kind of pattern-matching takes a bit of effort to grasp, and forces people using the library to know about the internal structure of the Vector and Matrix data structures they create.

Because of the impossibility of looking inside a map during guard-clauses, and on the other hand the impossibility to write macros that manage pattern-matching, we find ourselves an interesting Catch-22. This makes things like `is_vector()` or `is_matrix()` impossible.

An alternate approach that is possible is to pattern-match a vector or matrix as `%Vector{}` or `%Matrix{}`. This looks like the principle of least surprise to me.

The drawback of this second approach, is that it is no longer possible to pattern match on any tensor; in that case, indirection such as the following is required:

``````def some_function(tensor = %tensor_module{}) when is_tensor_module(tensor_module) do
...
end

defmacro is_tensor_module(module) do
quote do
unquote(module) in [Vector, Matrix, Tensor]
end
end
``````

which looks a bit clumsy, and at least also harder to understand to me. All functions inside the library (and all functions outside of it that are supposed to work on any order Tensor) would need this kind of pattern-match/guard macro combo.

So, now I am wondering: What is the better approach here?

• Keep a single `%Tensor{}` struct, and accept that people have a higher learning- and pattern-matching curve.

or:

• Have `%Vector{}`, `%Matrix{}` and `%Tensor{}` as three structs(that are the same, except in name) and modify all functions in the library to accept any of them using above-mentioned guard-macro.
1 Like

what if you have `%Tensor{type: :vector}`

3 Likes