Internal

versioninfo(io::IO = stdout; jll::Bool = false, full::Bool = false)

Print the version numbers of GAP.jl and GAP, and version numbers and installation paths of all currently loaded GAP packages. Note that these paths can be nonstandard because Julia's package manager does not control which available version of a GAP package gets loaded.

If jll or full is true then also the underlying binary packages (jll), if available, of all installed (not necessarily loaded) packages are included in the output.

get_symbols_in_module(m::Module) :: Vector{Symbol}

Return all symbols in the module m. This is used in a GAP method for RecNames.

GAP.jl is the Julia interface to the GAP-System.

For the package manual see https://oscar-system.github.io/GAP.jl/.

For more information about GAP see https://www.gap-system.org/.

RecDict_g = IdDict{Any,Any}

An internal type of GAP.jl used for tracking conversion results in julia_to_gap. The value stored at the key obj is the result of the Julia to GAP conversion of obj.

RecDict_j = IdDict{Tuple{Any, Type}, Any}

An internal type of GAP.jl used for tracking conversion results in gap_to_julia. The value stored at the key (obj, T) is the result of the GAP to Julia conversion of obj that has type T. Note that several Julia types can occur for the same GAP object.

Lookups for the key (obj, T) in an IdDict are successful if the conversion result of an object identical to obj with target type T has been stored in the dictionary.

Note that comparing two GapObjs with === yields the same result as comparing them with GAP.Globals.IsIdenticalObj because GapObj is a mutable type.

gap_to_julia_internal(::Type{T}, x::Any, rec_dict::JuliaCacheDict, ::Val{recursive}) where {T, recursive}

returns an object of type T that corresponds to the GAP object x.

The function gap_to_julia may call gap_to_julia_internal, but the other direction is not allowed.

New methods for the conversion from GAP to Julia shall be implemented via methods for gap_to_julia_internal not for gap_to_julia.

_gap_to_julia([::Type{T}, ]x::Obj[, recursive::Bool])

This function implements the GAP function GAPToJulia. It just delegates to gap_to_julia. Its purpose is to turn the recursive argument into a keyword argument, which is easier in Julia than in GAP.

kwarg_wrapper(func, args::Vector{T1}, kwargs::Dict{Symbol,T2}) where {T1, T2}

Call the function func with arguments args and keyword arguments given by the keys and values of kwargs.

This function is used on the GAP side, in calls of Julia functions that require keyword arguments.

Examples

julia> range(2, length = 5, step = 2)
2:2:10

julia> GAP.kwarg_wrapper(range, [2], Dict(:length => 5, :step => 2))
2:2:10