Руководство по стилю

{
    "translate_tabs_to_spaces": true,
    "tab_size": 4,
    "trim_trailing_white_space_on_save": true,
    "ensure_newline_at_eof_on_save": true,
    "rulers": [92]
}

set tabstop=4                             " Sets tabstops to a width of four columns.
set softtabstop=4                         " Determines the behaviour of TAB and BACKSPACE keys with expandtab.
set shiftwidth=4                          " Determines the results of >>, <<, and ==.

au FileType julia setlocal expandtab      " Replaces tabs with spaces.
au FileType julia setlocal colorcolumn=93 " Highlights column 93 to help maintain the 92 character line limit.

# Да:
foo(x::Int64) = abs(x) + 3
# Нет:
foobar(array_data::AbstractArray{T}, item::T) where {T<:Int64} = T[
    abs(x) * abs(item) + 3 for x in array_data
]

# Нет:
foobar(
    array_data::AbstractArray{T},
    item::T,
) where {T<:Int64} = T[abs(x) * abs(item) + 3 for x in array_data]
# Да:
function foobar(array_data::AbstractArray{T}, item::T) where T<:Int64
    return T[abs(x) * abs(item) + 3 for x in array_data]
end

# Да:
function fnc(x)
    result = zero(x)
    result += fna(x)
    return result
end
# Нет:
function fnc(x)
    result = zero(x)
    result += fna(x)
end

# Да:
function Foo(x, y)
    return new(x, y)
end
# Нет:
function Foo(x, y)
    new(x, y)
end

# Да:
function foobar(
    df::DataFrame,
    id::Symbol,
    variable::Symbol,
    value::AbstractString,
    prefix::AbstractString="",
)
    # код
end

# Приемлемо:
function foobar(df::DataFrame, id::Symbol, variable::Symbol, value::AbstractString, prefix::AbstractString="")
    # код
end
# Нет:
function foobar(df::DataFrame, id::Symbol, variable::Symbol, value::AbstractString,
    prefix::AbstractString="")

    # код
end
# Нет:
function foobar(
        df::DataFrame,
        id::Symbol,
        variable::Symbol,
        value::AbstractString,
        prefix::AbstractString="",
    )
    # код
end

# Да:
xy = foo(x; y=3)
# Нет:
xy = foo(x, y=3)

Yes: spam(ham[1], [eggs])
No:  spam( ham[ 1 ], [ eggs ] )

Yes: if x == 4 @show(x, y); x, y = y, x end
No:  if x == 4 @show(x , y) ; x , y = y , x end

Yes: ham[1:9], ham[1:3:9], ham[1:3:end]
No:  ham[1: 9], ham[1 : 3: 9]

Yes: ham[lower:upper], ham[lower:step:upper]
Yes: ham[lower + offset : upper + offset]
Yes: ham[(lower + offset):(upper + offset)]
No:  ham[lower + offset:upper + offset]

# Да:
x = 1
y = 2
long_variable = 3

# Нет:
x             = 1
y             = 2
long_variable = 3

# Да:
f(a::AbstractArray{T, N}) where {T<:Real, N} = ...
g(a::AbstractArray{<:Real, N}) where {N} = ...

# Нет:
f(a::AbstractArray{T, N}) where {T <: Real, N} = ...
g(a::AbstractArray{<: Real, N}) where {N} = ...

Yes: i = i + 1
No:  i=i+1

Yes: submitted += 1
No:  submitted +=1

Yes: x^2 < y
No:  x^2<y

# Да:
arr = [
    1,
    2,
    3,
]
arr = [
    1, 2, 3,
]
result = Function(
    arg1,
    arg2,
)
arr = [1, 2, 3]


# Нет:
arr =
[
    1,
    2,
    3,
]
arr =
[
    1, 2, 3,
]
arr = [
    1,
    2,
    3,
    ]

# Да:
x = [
    [
        1, 2, 3,
    ],
    [
        "hello",
        "world",
    ],
    ['a', 'b', 'c'],
]

# Нет:
y = [
    [
        1, 2, 3,
    ], [
        "hello",
        "world",
    ],
]
z = [[
        1, 2, 3,
    ], [
        "hello",
        "world",
    ],
]

# Да:
arr = [
    1,
    2,
    3,
]
result = Function(
    arg1,
    arg2,
)
arr = [1, 2, 3]

# Нет:
arr = [
    1,
    2,
    3
]
result = Function(
    arg1,
    arg2
)
arr = [1, 2, 3,]

# Да:
str = """
    hello
    world!
    """
str = """
        hello
    world!
    """
cmd = ```
    program
        --flag value
        parameter
      ```

# Нет:

str = """
    hello
    world! """

# Да:
x = x + 1      # Компенсация границы

# Нет:
x = x + 1      # Увеличиваем x

# Комментарий
code

# Еще один комментарий
more code

TODO

"""
    bar(x[, y])

Compute the Bar index between `x` and `y`. If `y` is missing, compute the Bar index between
all pairs of columns of `x`.
"""
function bar(x, y) ...

"""
    MyArray{T,N}

My super awesome array wrapper!

# Поля
- `data::AbstractArray{T,N}`: stores the array being wrapped
- `metadata::Dict`: stores metadata about the array
"""
struct MyArray{T,N} <: AbstractArray{T,N}
    data::AbstractArray{T,N}
    metadata::Dict
end

"""
    mysearch(array::MyArray{T}, val::T; verbose=true) where {T} -> Int

Searches the `array` for the `val`. For some reason we don't want to use Julia's
builtin search :)

# Аргументы
- `array::MyArray{T}`: the array to search
- `val::T`: the value to search for

# Именованные аргументы
- `verbose::Bool=true`: print out progress details

# Возвращает
- `Int`: the index where `val` is located in the `array`

# Выдает
- `NotFoundError`: I guess we could throw an error if `val` isn't found.
"""
function mysearch(array::AbstractArray{T}, val::T) where T
    ...
end

"""
    Manager(args...; kwargs...) -> Manager

A cluster manager which spawns workers.

# Аргументы

- `min_workers::Integer`: The minimum number of workers to spawn or an exception is thrown
- `max_workers::Integer`: The requested number of worker to spawn

# Именованные аргументы

- `definition::AbstractString`: Name of the job definition to use. Defaults to the
    definition used within the current instance.
- `name::AbstractString`: ...
- `queue::AbstractString`: ...
"""
function Manager(...)
    ...
end

"""
    Manager(max_workers; kwargs...)
    Manager(min_workers:max_workers; kwargs...)
    Manager(min_workers, max_workers; kwargs...)

A cluster manager which spawns workers.

# Аргументы

- `min_workers::Int`: The minimum number of workers to spawn or an exception is thrown
- `max_workers::Int`: The number of requested workers to spawn

# Именованные аргументы

- `definition::AbstractString`: Name of the job definition to use. Defaults to the
    definition used within the current instance.
- `name::AbstractString`: ...
- `queue::AbstractString`: ...
"""
function Manager end

"""
...

# Именованные аргументы
- `definition::AbstractString`: Name of the job definition to use. Defaults to the
    definition used within the current instance.
"""

@testset "PkgExtreme" begin
    include("arithmetic.jl")
    include("utils.jl")
end

# Да:
@test value == 0

# Нет:
@test value == 0.0

# Проверяем, находится ли отклонение m и s соответственно от 1,5 и 2,2 в пределах единицы.
check_numerical(chain, [:m, :s], [1.5, 2.2], atol = 1.0)

# Проверяет оценки для модели gdemo по умолчанию с использованием значений 1,5 и 2,0.
check_gdemo(chain, atol = 0.1)

# Проверяет оценки для модели MoG по умолчанию.
check_MoGtest_default(chain, atol = 0.1)