CTBase.jl

CTBase module.

Lists all the imported modules and packages:

• Base
• Core
• DocStringExtensions

DescVarArg is a Vararg of symbols. DescVarArg is a type alias for a Vararg of symbols.

julia> const DescVarArg = Vararg{Symbol}

See also: Description.

struct AmbiguousDescription <: CTBase.CTException

Exception thrown when the description is ambiguous / incorrect.

Fields

• var::Tuple{Vararg{Symbol}}

Example

julia> complete(:f; descriptions=((:a, :b), (:a, :b, :c))
ERROR: AmbiguousDescription: the description (:f,) is ambiguous / incorrect

abstract type CTException <: Exception

Abstract type for exceptions.

A description is a tuple of symbols. Description is a type alias for a tuple of symbols.

julia> const Description = Tuple{DescVarArg}

See also: DescVarArg.

Example

Base.show is overloaded for descriptions, that is tuple of descriptions are printed as follows:

julia> display( ( (:a, :b), (:b, :c) ) )
(:a, :b)
(:b, :c)

struct ExtensionError <: CTBase.CTException

Exception thrown when an extension is not loaded but the user tries to call a function of it.

Fields

• weakdeps::Tuple{Vararg{Symbol}}

struct IncorrectArgument <: CTBase.CTException

Exception thrown when an argument is inconsistent.

Fields

• var::String

struct IncorrectMethod <: CTBase.CTException

Exception thrown when a method is incorrect.

Fields

• var::Symbol

struct IncorrectOutput <: CTBase.CTException

Exception thrown when the output is incorrect.

Fields

• var::String

struct NotImplemented <: CTBase.CTException

Exception thrown when a method is not implemented.

Fields

• var::String

struct ParsingError <: CTBase.CTException

Exception thrown for syntax error during abstract parsing.

Fields

• var::String

struct UnauthorizedCall <: CTBase.CTException

Exception thrown when a call to a function is not authorized.

Fields

• var::String

Type alias for a real number.

julia> const ctNumber = Real

show(
    io::IO,
    _::MIME{Symbol("text/plain")},
    descriptions::Tuple{Vararg{Tuple{Vararg{Symbol}}}}
)

Print a tuple of descriptions.

Example

julia> display( ( (:a, :b), (:b, :c) ) )
(:a, :b)
(:b, :c)

showerror(io::IO, e::CTBase.AmbiguousDescription)

Print the exception.

showerror(io::IO, e::CTBase.ExtensionError)

Print the exception.

showerror(io::IO, e::CTBase.IncorrectArgument)

Print the exception.

showerror(io::IO, e::CTBase.IncorrectMethod)

Print the exception.

showerror(io::IO, e::CTBase.IncorrectOutput)

Print the exception.

showerror(io::IO, e::CTBase.NotImplemented)

Print the exception.

showerror(io::IO, e::CTBase.UnauthorizedCall)

Print the exception.

showerror(io::IO, e::ParsingError)

Print the exception.

__display() -> Bool

Used to set the default value of the display argument. The default value is true, which means that the output is printed during execution.

add(
    x::Tuple{Vararg{Tuple{Vararg{Symbol}}}},
    y::Tuple{Vararg{Symbol}}
) -> Tuple{Tuple{Vararg{Symbol}}}

Add the description y to the tuple of descriptions x if x does not contain y and return the new tuple of descriptions.

Throw an exception (IncorrectArgument) if the description y is already contained in x.

Example

julia> descriptions = ()
julia> descriptions = add(descriptions, (:a,))
(:a,)
julia> descriptions = add(descriptions, (:b,))
(:a,)
(:b,)
julia> descriptions = add(descriptions, (:b,))
ERROR: IncorrectArgument: the description (:b,) is already in ((:a,), (:b,))

add(
    _::Tuple{},
    y::Tuple{Vararg{Symbol}}
) -> Tuple{Tuple{Vararg{Symbol}}}

Return a tuple containing only the description y.

Example

julia> descriptions = ()
julia> descriptions = add(descriptions, (:a,))
(:a,)
julia> print(descriptions)
((:a,),)
julia> descriptions[1]
(:a,)

complete(list::Symbol...; descriptions)

Return one description from a list of Symbols list and a set of descriptions D. If multiple descriptions are possible, then the first one is selected.

If the list is not contained in any of the descriptions, then an exception is thrown.

Example

julia> D = ((:a, :b), (:a, :b, :c), (:b, :c), (:a, :c))
(:a, :b)
(:b, :c)
(:a, :c)
julia> complete(:a; descriptions=D)
(:a, :b)
julia> complete(:a, :c; descriptions=D)
(:a, :b, :c)
julia> complete((:a, :c); descriptions=D)
(:a, :b, :c)
julia> complete(:f; descriptions=D)
ERROR: AmbiguousDescription: the description (:f,) is ambiguous / incorrect

ctindice(i::Int64) -> Char

Return i ∈ [0, 9] as a subscript.

If i is not in the range, an exception is thrown.

ctindices(i::Int64) -> String

Return i > 0 as a subscript.

If i is not in the range, an exception is thrown.

ctupperscript(i::Int64) -> Char

Return i ∈ [0, 9] as an upperscript.

If i is not in the range, an exception is thrown.

ctupperscripts(i::Int64) -> String

Return i > 0 as an upperscript.

If i is not in the range, an exception is thrown.

remove(
    x::Tuple{Vararg{Symbol}},
    y::Tuple{Vararg{Symbol}}
) -> Tuple{Vararg{Symbol}}

Return the difference between the description x and the description y.

Example

julia> remove((:a, :b), (:a,))
(:b,)