Hi! :slightly_smiling_face: I have a Matrix class...

# announcements

[mplain]

Hi! 🙂

I have a Matrix class with a primary constructor that takes two integer arguments (rows and columns) and a supplier function that tells it how to get its next element based on its indices:

class Matrix<N : Number>(private val rows: Int, private val columns: Int, f: (Int, Int) -> N) : List<List<N>>
by List(rows, { i -> List(columns) { j -> f.invoke(i, j) } }) {

Now I want to add a secondary constructor that would take an iterable (list or array) of elements, like this:

constructor(rows: Int, columns: Int, values: Iterable<N>) {
    val iterator = values.iterator()
    Matrix(rows, columns) { _, _ -> iterator.next() }
}

This doesn't work, says "call to primary constructor expected"
Any advice on how to address this problem, Kotlin-style?

[Joost Klitsie]

I think your constructor should do something like this:

constructor(rows: Int, columns: Int, values: Iterable<N>) : this(rows, columns...)

[mplain]

this is meant to call a primary constructor and then add some extra properties to it

[Joost Klitsie]

constructor(rows: Int, columns: Int, values: Iterable<N>): this(rows, columns, { _, _ -> values.iterator().next() })

[mplain]

that won't work, it will set all elements to the first value of the list

[Joost Klitsie]

To me it looks the same as your example

[mplain]

in your code, for each element, a new instance of iterator will be created

[Joost Klitsie]

you want to call the primary constructor like Matrix(...)

[mplain]

and thus in will provide the first element, always

[Joost Klitsie]

perhaps

[mplain]

i tried that 🙂

[Joost Klitsie]

ah

[Joost Klitsie]

yeah perhaps make a static helper function?

[mplain]

yeah, this would do probably

[mplain]

i also tried making two "secondary" constructors (so none of them primary)

[mplain]

but then i don't know how to delegate properly

[Joost Klitsie]

companion object {
		operator fun <N: Number> invoke(rows: Int, columns: Int, values: Iterable<N>) {
			val iterator = values.iterator()
			Matrix(rows, columns) { _, _ -> iterator.next() }
		}
	}

[Joost Klitsie]

then you can call it like this:

Matrix(5, 5, listOf(5))

[Joost Klitsie]

of course I miss a return statement 😄 but you get the gist

[mplain]

ah, so you mean like a helper Invoke function so that my constructor would work?

[mplain]

i thought you meant make a factory function instead of a secondary constructor

[Joost Klitsie]

yep

[mplain]

but i think if i make a helper invoke function, it will still complain that a call to the primary constructor is expected

[mplain]

that's the point, if i have a primary constructor, the secondary one MUST call the primary one

[Joost Klitsie]

as I said the return was missed

companion object {
		operator fun <N: Number> invoke(rows: Int, columns: Int, values: Iterable<N>): Matrix<N> {
			val iterator = values.iterator()
			return Matrix(rows, columns) { _, _ -> iterator.next() }
		}
	}

This helper function instantiates a Matrix<N> object

[mplain]

oh Kotlin, some of your features are extra obscure =_=

[Joost Klitsie]

so basically you override the invoke() function of the companion object with a certain set of arguments

[mplain]

ah, so this would be instead of a secondary constructor

[Joost Klitsie]

which in terms you make it return the actual object

[mplain]

not a factory function, but rather an invoke

[mplain]

yeah, that would work

[mplain]

thanks!

[mplain]

I also did this:

constructor(rows: Int, columns: Int, values: List<N>) : this(rows, columns, { i, j -> values[i * columns + j] })