Repository: JuliaLang/julia
File: base/docs/basedocs.jl (Julia)

Code before:
as well as many great tutorials and learning resources:

    https://julialang.org/learning/

For help on a specific function or macro, type `?` followed
by its name, e.g. `?cos`, or `?@time`, and press enter.
Type `;` to enter shell mode, `]` to enter package mode.
"""
kw"help", kw"Julia", kw"julia", kw""

"""
    using

`using Foo` will load the module or package `Foo` and make its [`export`](@ref)ed names
available for direct use. Names can also be used via dot syntax (e.g. `Foo.foo` to access
the name `foo`), whether they are `export`ed or not.
See the [manual section about modules](@ref modules) for details.

!!! note
    Doing `using Foo` in packages or code that you want to keep working with
    updated dependencies is not recommended. The reason for this is if another
    dependency starts to export one of the same names as `Foo` the code will
    error due to an ambiguity in which package the name should be taken from.
    Instead, explicitly list what names you want to use from Foo, for example:
    `using Foo: Foo, parsefile, readfile` to get access bring `Foo` and two
    functions `parsefile` and `readfile` into scope.
"""
kw"using"

"""
    import

`import Foo` will load the module or package `Foo`.
Names from the imported `Foo` module can be accessed with dot syntax
(e.g. `Foo.foo` to access the name `foo`).
See the [manual section about modules](@ref modules) for details.
"""
kw"import"

"""
    export

`export` is used within modules to tell Julia which functions should be
made available to the user. For example: `export foo` makes the name
`foo` available when [`using`](@ref) the module.
See the [manual section about modules](@ref modules) for details.
"""
kw"export"

"""
    abstract type

Review comment (suggestion):
```suggestion
!!! note
    If two packages export the same name and are both loaded with `using`,
    and the name is referenced, an error will be thrown, as Julia can't know
    which source of the name was intended. To mitigate this, you may prefer to
    explicitly list which names you want to use from a package, for example:
    `using Foo: Foo, f, g` to bring `Foo` and two functions `f` and `g` into
    scope. (Note that a conflict does not occur if two packages export the
    exact same function, e.g. if both add methods to a common function, or
    if packages export a function with the same name but the code that uses
    the packages does not reference it.)
```

Code after:

as well as many great tutorials and learning resources:

    https://julialang.org/learning/

For help on a specific function or macro, type `?` followed
by its name, e.g. `?cos`, or `?@time`, and press enter.
Type `;` to enter shell mode, `]` to enter package mode.

To exit the interactive session, type `CTRL-D` (press the
control key together with the `d` key), or type `exit()`.
"""
kw"help", kw"Julia", kw"julia", kw""

"""
    using

`using Foo` will load the module or package `Foo` and make its [`export`](@ref)ed names
available for direct use. Names can also be used via dot syntax (e.g. `Foo.foo` to access
the name `foo`), whether they are `export`ed or not.
See the [manual section about modules](@ref modules) for details.

!!! note
    When two or more packages/modules export a name and that name does not refer to the
    same thing in each of the packages, and the packages are loaded via `using` without
    an explicit list of names, it is an error to reference that name without qualification.
    It is thus recommended that code intended to be forward-compatible with future versions
    of its dependencies and of Julia, e.g., code in released packages, list the names it
    uses from each loaded package, e.g., `using Foo: Foo, f` rather than `using Foo`.
"""
kw"using"

"""
    import

`import Foo` will load the module or package `Foo`.
Names from the imported `Foo` module can be accessed with dot syntax
(e.g. `Foo.foo` to access the name `foo`).
See the [manual section about modules](@ref modules) for details.
"""
kw"import"

"""
    export

`export` is used within modules to tell Julia which names should be
made available to the user. For example: `export foo` makes the name
`foo` available when [`using`](@ref) the module.
See the [manual section about modules](@ref modules) for details.
"""
kw"export"