Return type of getattribute functions

[IssamT]

Is a detailed documentation enough or should we have something like the following?

abstract type AbstractSolverInstanceAttribute{T} end
...

and

function getattribute(m, attr::AnyAttribute{T}, args...)::T

We can have shortcuts like NumberOfVariables <: AbstractSolverInstanceAttribute{Int}

[mlubin]

I can see it being useful to be able to know programmatically which type an attribute corresponds to.

• For RawSolver we say <: AbstractSolverInstanceAttribute{Any}?
• ListOfConstraints is <: AbstractSolverInstanceAttribute{Vector{Any}} or <: AbstractSolverInstanceAttribute{Any} or something more specific?

Note that most solver instances won't implement

function getattribute(m, attr::AnyAttribute{T}, args...)::T

They will implement separate getattribute methods, e.g.,

function getattribute(m::GurobiSolverInstance, attr::NumberOfVariables)
...

so it's not that relevant to the implementation.

[IssamT]

You are right. My suggestion will not put any restriction on the method implementation of the solver. And I don't think it is possible to do it in Julia as long as the method implemented by the solver is the final one to be called by the user.

What about adding a check like this? But I don't know it s very useful... It only helps find errors that are on the solver side.

function getattribute{T}(m, attr::AnyAttribute{T})
    ret = solvergetattribute(m, attr)
    if isa(ret, T)
        ret
    else
        error("attribute $(typeof(attr)) should have a return of type $T")
    end
end 

[mlubin]

I don't see a reason to impose that extra level of indirection, except for debugging purposes.
MOI is an interface and it's up to the solvers to implement it properly. There are lots of other places where we have to trust that the implementation is correct.

[IssamT]

can julia inline this?

getattribute{T}(m, attr::AnyAttribute{T})::T = solvergetattribute(m, attr)

P.S. This would only check that the return type is convertible to T. So not that strong...

I think we are not the only ones facing such issue with interfaces.

JuliaLang/julia#6975

by the way, why do you provide the arguments? do they restrict something , or they could as well have been written just in the documentation ?

[mlubin]

Arguments to getattribute are used for providing variable or constraint references, for variable-wise and constraint-wise attributes.

[IssamT]

Typeclass.jl offers a nice solution, but the package doesn't seem to be actively maintained.

Example of interface definition:

@class MOISolverInstance M begin
       getattribute(m::M,attr::NumberOfVariables)::Int
       getattribute(m::M,attr::NumberOfConstraints)::Int
       # etc
end

Example of solver side implementation

@instance MOISolverInstance GurobiSolverInstance begin
    getattribute(m::GurobiSolverInstance, attr::NumberOfVariables)::Int = # defined the Gurobi way
    getattribute(m::GurobiSolverInstance, attr::NumberOfConstraints)::Int = # defined the Gurobi way
    # etc
end

[mlubin]

It's not a bad idea in principle, but MOI should not depend on packages like that. One new release of Typeclass.jl could break the whole JuliaOpt ecosystem.

[mlubin]

@IssamT, the return types can be checked in the unit tests. Would that address your concern?

[IssamT]

Yes. I am fine with the unit tests. My comment was mostly for the record in case we face issues in the future.

I was reading about what julia is offering in term of clean interfaces and I found that the answer is: almost nothing. and the issue I mentioned about interfaces was unfortunately moved to the milestone 2+.

[IssamT]

Feel free to close this issue :)

[mlubin]

I still think there's value in making the return type accessible programmatically given the attribute object.

[IssamT]

As a user of other libraries, I sometimes tend to use @show typeof(x) or eltype(x), to understand what is the type I got. So you are right, it might be useful to have something like:

valuetype{T}(attr::AnyAttribute{T}) = T

EDIT:

maybe better

valuetype{T,R<:AnyAttribute{T}}(attr::R) = T