Make keyword argument names consistent

[mroavi]

For consistency, I propose changing this constructor signature from:

MetaGraphsNext.MetaGraph(graph::AbstractGraph{T}; Label, VertexData, EdgeData, graph_data, weight_function, default_weight) where T 

to

MetaGraphsNext.MetaGraph(graph::AbstractGraph{T}; label, vertex_data, edge_data, graph_data, weight_function, default_weight) where T 

[mroavi]

Hmm. I think I understand now. The pascal case is being used to distinguish arguments that expect a type. This wasn't obvious to me. I haven't seen this convention in other Julia packages. What about making it a bit more verbose but more clear at the same time:

MetaGraphsNext.MetaGraph(graph::AbstractGraph{T}; label_type, vertex_data_type, edge_data_type, graph_data, weight_function, default_weight) where T 

[bramtayl]

Yup, I came up with that convention. I kind of like it; vertex_data_type seems a bit long for a keyword. But I don't have strong opinions about it.

[mroavi]

Would be nice to hear other people's opinions. In my opinion, it breaks an important styling convention advocated in Julia's Base lib where variables (arguments in this case) are defined in lower case and actual types (or modules) in upper case.

[gdalle]

I don't have strong opinions either but I don't really like that constructor anyway, since it is not inferrable. I think #6 will be part of the answer

[bramtayl]

it is not inferrable

Oof I didn't realize that. Even with constant propagation of the types? That seems like arguably a bug in base.

[gdalle]

Oof I didn't realize that. Even with constant propagation of the types? That seems like arguably a bug in base.

I think types as kwargs are never inferrable, are they? Anyway, working on fixing it with a new constructor for upcoming v0.5

[bramtayl]

types as kwargs are never inferrable

This seems to work?

using Test: @inferred

function keyword_function(; key_type = Symbol, value_type = Int)
    return Dict{key_type, value_type}()
end

function wrapper_function()
    keyword_function(; key_type = String)
end

@inferred keyword_function()
@inferred wrapper_function()

[gdalle]

It does but this fails for instance

julia> @inferred keyword_function(; key_type=String)
ERROR: return type Dict{String, Int64} does not match inferred return type Dict{_A, Int64} where _A
Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:35

I think it's the same topic as this recent discourse thread https://discourse.julialang.org/t/keyword-arguments-and-type-stability/94993

[bramtayl]

Oh, right sure, that's not with constant propagation though.

[gdalle]

I documented it in more detail in #45