Julia (язык программирования)

Материал из Национальной библиотеки им. Н. Э. Баумана
Последнее изменение этой страницы: 20:11, 1 июня 2016.
Julia
Julia (programming language) logo.png
Парадигма С множественной диспетчеризацией ("объектно-ориентированной"), процедурный, функциональный, язык мета-программирования
Спроектировано Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman
Разработчики Jeff Bezanson, Stefan Karpinski, Viral B. Shah, и другие
Первый   появившийся 2012
Стабильная версия 0.4.1 / 0.3.12 / 2015.11.8 (v0.4.1)
Предварительный выпуск 0.5.0-dev / обновляется ежедневно
Печать дисциплины Динамическая с опциональной типизацией
OS Linux, OS X, FreeBSD, Windows
Лицензия MIT
Расширение файла .jl
Портал: julialang.org
Под влиянием
MATLAB, Lisp, Scheme, C, Fortran, Mathematica, Python, Perl, R, Ruby, Lua

Julia - это высокоуровневый язык программирования, разработанный для удовлетворения требованиий высокой производительности в числовых и научных вычислениях, а также для эффективного программирования общего назначения, веб-использования или в качестве языка спецификаций. Отличительные особенности конструкции Джулии включают наличие системы типов с параметрическими типами в полностью динамическом языке программирования, и принятие множественной диспетчеризации в качестве своей основной парадигмы программирования. Это позволяет производить одновременные, параллельные и распределенные вычисления, напрямую вызывать библиотеки, написанные на Си и Фортран. Julia снабжен сборщиком мусора, использует "жадное" выполнение, и включает в себя эффективные библиотеки для вычислений с плавающей точкой, линейной алгебры, генерации случайных чисел, быстрого преобразования Фурье и работы с регулярными выражениями. Julia новый функциональный язык, предназначенный для технических вычислений. Имея полную мощность макросов, функций первого класса, и контроля на низком уровне, язык Julia легок в освоении и использовании, как Python.

Особенности языка

По данным официального сайта, основные особенности языка:

  • Множественная диспетчеризация: обеспечение способности определить поведение функции во многих комбинациях типов аргументов
  • Динамическая система типизации: типы для документации, оптимизации и отправки
  • Хорошая производительность, приближается к статически-типизированным языкам, таким как C
  • Встроенный менеджер пакетов
  • Макросы и другие средства метапрограммирования
  • Вызов функций Python: с использованием пакета PyCall
  • Прямой вызов функций C: отсутствие обертки или специального интерфейса
  • Мощные возможности для управления другими процессами (как у shell)
  • Предназначен для параллельных и распределенных вычислений
  • Сопрограммы: легкая "зеленая" многопоточность
  • Определяемые пользователем типы работают так же быстро, как и встроенные модули
  • Автоматическая генерация эффективного кода для различных типов аргументов
  • Элегантные и расширяемые преобразования для числовых и других типов
  • Эффективная поддержка Unicode, в том числе, но не ограничиваясь, UTF-8

Использование

Официальный дистрибутив Julia включает в себя интерактивную оболочку сессии, под названием REPL Julia, которая может быть использована, чтобы экспериментировать и тестировать код быстро. Следующий фрагмент представляет собой пример сеанса на REPL: The Julia official distribution includes an interactive session shell, called Julia's REPL, which can be used to experiment and test code quickly. The following fragment represents a sample session on the REPL:

julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!

REPL дает пользователю доступ к системной оболочке и режиму справки, по нажатию ; или? после строки (предворяющей каждую команду), соответственно. REPL также хранит историю команд, даже между сессиями. Другие примеры смотрите в документации Julia, где приводится код, который может быть протестирована в интерактивной сессии Julia или сохранен в файле с расширением .jl и запущен из командной строки при вводе команды (например):

$ julia <filename>

Julia также поддерживается Jupyter, онлайн интерактивной среды разработки для "ноутбуков" (проект Jupyter является многоязыковым расширением, "переросшим" из командной оболочки IPython и теперь включает в себя IJulia). Смотрите другие способы в следующем разделе.

Использование с другими языками

В Julia ключевое слово Ccall используется для вызова библиотечных функций на С (или Fortran).

Julia имеет поддержку Unicode, с UTF-8, используемой для исходного кода и позволяющей вводить общие математические символы для многих операторов, таких как ∈ для оператора включения. Для строк полностью поддерживаются кодировки UTF-8, UTF-16 и UTF-32 (и ASCII).

В Julia есть пакеты, поддерживающие языки разметки, такие как HTML (разбор, а также для HTTP), XML, JSON, BSON (и MongoDB) и т.д.

Синтаксис

Описание базового синтаксиса для Julia версии 0.3.

Комментарии

Однострочные комментарии начинаются с символа "#" (решетка). Многострочные комментарии могут быть записаны, поставив "# = 'перед текстом и' = '# после текста. Они также могут быть вложенными.

Примитивные типы данных и операторы

В Julia все является выражением. Есть несколько основных типов чисел:

3 # => 3 (Int64)
3.2 # => 3.2 (Float64)
2 + 1im # => 2 + 1im (Complex{Int64})
2//3 # => 2//3 (Rational{Int64})

Все основные инфиксные операторы доступны.

1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7.0
5 / 2 # => 2.5 # деление Int на Int обычно возвращает Float
div(5, 2) # => 2 # для целочисленного деления используйте div
5 \ 35 # => 7.0
2 ^ 2 # => 4 # возведение в степень, не побитовый xor
12 % 10 # => 2

Приоритеты обеспечиваются скобками

(1 + 3) * 2 # => 8

Побитовые операторы

~2 # => -3   # Побитовый not
3 & 5 # => 1 # Побитовый and
2 | 4 # => 6 # Побитовый or
2 $ 4 # => 6 # Побитовый xor
2 >>> 1 # => 1 # логический сдвиг вправо
2 >> 1  # => 1 # арифметический сдвиг вправо
2 << 1  # => 4 # логический/арифметический сдвиг влево

Вы можете использовать функциональность для отображения бинарного представления числа.

bits(12345) # => "0000000000000000000000000000000000000000000000000011000000111001"
bits(12345.0) # => "0100000011001000000111001000000000000000000000000000000000000000"

Булевы значения являются приметивными

true
false

Булевы операторы

!true # => false
!false # => true
1 == 1 # => true
2 == 1 # => false
1 != 1 # => false
2 != 1 # => true
1 < 10 # => true
1 > 10 # => false
2 <= 2 # => true
2 >= 2 # => true

Сравнения могут быть соединены

1 < 2 < 3 # => true
2 < 3 < 2 # => false

Строки заключаются в ""

"Это строка."

В Julia есть несколько типов строк, включая ASCIIString и UTF8String. Подробнее об этом в разделе Типы. Символьные литералы записываются в

'a'

Некоторые строки могут быть проиндексированы, как массив символов

"Это строка."[1] # => 'T' # Julia индексирует с 1 !!!

Тем не менее, это не будет хорошо работать для строки в кодировке UTF8, поэтому рекомендуется итерирование по строкам. $ может быть использован для интерполяции строк:

"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"

Вы можете поставить любое выражение в Julia в скобки. Еще один способ форматирования строк - макрос Printf.

@printf "%d меньше %f" 4.5 5.3 # 5 меньше 5.300000

Печатать легко:

println("Я Julia. Nice to meet you!")

Строки можно сравнивать лексикографически

"пока" > "хорошо" # => true
"хорошо" == "хорошо" # => true
"1 + 2 = 3" == "1 + 2 = $(1+2)" # => true

Переменные и коллекции

Не нужно обявлять переменные, перед присвоением им значения.

some_var = 5 # => 5
some_var # => 5

доступ к переменной, которой не присвоено значение, является ошибкой

try
    some_other_var # => ERROR: some_other_var не определена
catch e
    println(e)
end

Названия переменных начинаются с буквы или подчеркивания. Затем можно использовать буквы, цифры, подчеркивания и восклицательные знаки.

SomeOtherVar123! = 6 # => 6

Так же вы можете использовать определенные символы Unicode:

☃ = 8 # => 8

Это особенно удобно для математической нотации

2 * π # => 6.283185307179586

Замечание о именовании в Julia:

  • Для разделения слов может использовать подчеркивания _, но использование подчеркивания не рекомендуется, если только имя будет легко читаемо.
  • Имена типов начинаются с прописной буквы и разделяются с помощью CamelCase вместо подчеркивания.
  • Имена функций и макросов в нижнем регистре, без подчеркивания.
  • Функции, которые изменяют свои входные параметры, имеют имена, которые заканчиваются !. Эти функции иногда называют функциями мутирующими или in-place функциями.

Массивы хранят последовательность значений, проиндексированных числами от 1 до п:

a = Int64[] # => пустой Int64 массив

Одномерные массивы могут быть инициализированы значениями, записанными в [] через запятую

b = [4, 5, 6] # => 3-элементный Int64 массив: [4, 5, 6]
b[1] # => 4
b[end] # => 6

Двумерные массивы могут быть инициализированы значениями, записанными в [] через ;.

matrix = [1 2; 3 4] # => 2x2 Int64 массив: [1 2; 3 4]

Для добавления в конец списка используются push! and append!

push!(a,1)     # => [1]
push!(a,2)     # => [1,2]
push!(a,4)     # => [1,2,4]
push!(a,3)     # => [1,2,4,3]
append!(a,b) # => [1,2,4,3,4,5,6]

Удаление из конца с помощью pop:

pop!(b) # => 6 и b теперь [4,5]

Вернем ее назад:

push!(b,6)   # b is now [4,5,6] again.
a[1] # => 1 #

end - сокращение для последнего индекса и может быть использовано в любом индексном выражении

a[end] # => 6

Так же есть сдвиг и возврат

shift!(a) # => 1 и a теперь [2,4,3,4,5,6]
unshift!(a,7) # => [7,2,4,3,4,5,6]

Имена функций, заканчивающиеся на !, говорят о модификации передаваемых аргументов.

arr = [5,4,6] # => 3-элементный Int64 массив: [5,4,6]
sort(arr) # => [4,5,6]; arr все еще [5,4,6]
sort!(arr) # => [4,5,6]; arr теперь [4,5,6]

При выходе за гарницы массива возникает BoundsError

try
    a[0] # => ERROR: BoundsError() in getindex at array.jl:270
    a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
catch e
    println(e)
end

Ошибки указывают на линию в которой произошли, даже если она находится в стандартной библиотеке. Если вы собрали Julia из исходников, вы можете посмотреть в базовую директорию в директории Julia, чтобы найти эти файлы. Вы можете инициализировать массивы из диапазонов:

a = [1:5;] # => 5-элементный Int64 массив: [1,2,3,4,5]

Работать с range'ами можно с использованием splice:

a[1:3] # => [1, 2, 3]
a[2:end] # => [2, 3, 4, 5]

Удаляйте элементы массива по индексу с помощью splice!

arr = [3,4,5]
splice!(arr,2) # => 4 ; arr теперь [3,5]

Сращивайте списки с помощью append!

b = [1,2,3]
append!(a,b) # теперь [1, 2, 3, 4, 5, 1, 2, 3]

Проверяйте существование в списке с помощью in:

in(1, a) # => true

Узнавайте длину с помощью length:

length(a) # => 8

Кортежи являются неизменяемыми.

tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
tup[1] # => 1
try:
    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
catch e
    println(e)
end

Многие функции списоков также работают и с кортежами:

length(tup) # => 3
tup[1:2] # => (1,2)
in(2, tup) # => true

Вы можете распаковывать кортежи в переменные

a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3

Кортежи создаются даже если оставить в скобки:

d, e, f = 4, 5, 6 # => (4,5,6)

А 1-элемент кортежа отличается от значения, которое он содержит:

(1,) == 1 # => false
(1) == 1 # => true

Посмотрите, как легко поменять два значения:

e, d = d, e  # => (5,4) # d is now 5 and e is now 4

Словари хранят отображения:

empty_dict = Dict() # => Dict{Any,Any}()

Вы можете создать словарь, используя литералы:

filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] # => Dict{ASCIIString,Int64}

Просматривайте значения с помощью []:

filled_dict["one"] # => 1

Получить все ключи:

keys(filled_dict) # => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])

Примечание - ключи не сортируются и не сохраняют порядок их вставки. Получить все значения:

values(filled_dict) # => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])

Примечание - то же самое касается порядка ключей. Проверка существования ключей в словаре с помощью in, haskey:

in(("one", 1), filled_dict) # => true
in(("two", 3), filled_dict) # => false
haskey(filled_dict, "one") # => true
haskey(filled_dict, 1) # => false

Попытка искать несуществующий ключ выдаст ошибку:

try
    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
catch e
    println(e)
end

Используйте метод get, чтобы избежать этой ошибки, предоставляя значение по умолчанию: get(dictionary,key,default_value)

get(filled_dict,"one",4) # => 1
get(filled_dict,"four",4) # => 4

Используйте множества, чтобы представлять коллекции неупорядоченных уникальных значений:

empty_set = Set() # => Set{Any}()

Инициализация множества со значениями:

filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)

Добавить еще значения в множество:

push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)

Проверить, что значение в множестве:

in(2, filled_set) # => true
in(10, filled_set) # => false

Есть функции для вычисления объединения, пересечения и разности.

other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)

Управление потоком выполнения

Создадим переменную:

some_var = 5

Это выражение. Отступы не имеет смысла в Julia.

if some_var > 10
    println("some_var is totally bigger than 10.")
elseif some_var < 10    # This elseif clause is optional.
    println("some_var is smaller than 10.")
else                    # The else clause is optional too.
    println("some_var is indeed 10.")
end
# => prints "some var is smaller than 10"

Для итерации используйте циклы: Итерирумыми являются Range, Array, Set, Dict, и AbstractString.

for animal=["dog", "cat", "mouse"]
    println("$animal млекопитающее")
    # Можно использовать $ для интерполяции выражения в строку
end
# выведет:
#    собака млекопитающее
#    кошка млекопитающее
#    мышь млекопитающее

Можно использовать 'in' вместо '='.

for animal in ["dog", "cat", "mouse"]
    println("$animal млекопитающее")
end

# выведет:
#    собака млекопитающее
#    кошка млекопитающее
#    мышь млекопитающее

for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
    println("$(a[1]) is a $(a[2])")
end

# выведет:
#    собака млекопитающее
#    кошка млекопитающее
#    мышь млекопитающее

for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
    println("$k is a $v")
end

# выведет:
#    собака млекопитающее
#    кошка млекопитающее
#    мышь млекопитающее

Цикл while повторяется пока условие верно (true):

x = 0
while x < 4
    println(x)
    x += 1
end

# выведет:
#   0
#   1
#   2
#   3

Обрабатывайте исключения с помощью блока try/catch:

try
   error("help")
catch e
   println("caught it $e")
end
# => caught it ErrorException("help")

Функции

Ключевое слово 'function' создает новые функции:

function name(arglist)
#  body...
#end
function add(x, y)
    println("x = $x и y = $y")

    # функция возвращает значение своего последнего выражения
    x + y
end

add(5, 6) # => 11 после вывода "x = 5 и y = 6"

Компактное определение функций:

f_add(x, y) = x + y # => "f (generic function with 1 method)"
f_add(3, 4) # => 7

Функция также может возвращать несколько значений, как кортеж:

f(x, y) = x + y, x - y
f(3, 4) # => (7, -1)

Вы можете определить функции, которые принимают переменное количество позиционных аргументов:

function varargs(args...)
    return args
    # используйте return для возврата из любого места функции
end
# => varargs (generic function with 1 method)

varargs(1,2,3) # => (1,2,3)

Выражение ... называется splat. Мы просто использовали его в определении функции. Он также может быть использован при вызове, где он будет превращать массив или содержимое кортежа в список аргументов.

Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)

x = (1,2,3)     # => (1,2,3)
Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
Set(x...)       # => Set{Int64}(2,3,1)

Вы можете определять функции с дополнительными позиционныvb аргументами:

function defaults(a,b,x=5,y=6)
    return "$a $b and $x $y"
end

defaults('h','g') # => "h g and 5 6"
defaults('h','g','j') # => "h g and j 6"
defaults('h','g','j','k') # => "h g and j k"
try
    defaults('h') # => ERROR: no method defaults(Char,)
    defaults() # => ERROR: no methods defaults()
catch e
    println(e)
end

Вы можете определить функции, которые принимают в качестве аргументов ключевые слова:

function keyword_args(;k1=4,name2="hello") # note the ;
    return ["k1"=>k1,"name2"=>name2]
end

keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
keyword_args() # => ["name2"=>"hello","k1"=>4]

Вы можете объединить все виды аргументов в той же функции:

function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
    println("normal arg: $normal_arg")
    println("optional arg: $optional_positional_arg")
    println("keyword arg: $keyword_arg")
end

all_the_args(1, 3, keyword_arg=4)

# выведет:
#   normal arg: 1
#   optional arg: 3
#   keyword arg: 4

В Julia есть first class - функции:

function create_adder(x)
    adder = function (y)
        return x + y
    end
    return adder
end

Это "stabby lambda syntax" для создания анонимных функций:

(x -> x > 2)(3) # => true

Эта функция идентична create_adder выше.

function create_adder(x)
    y -> x + y
end

Вы также можете назвать внутреннюю функцию, если хотите:

function create_adder(x)
    function adder(y)
        x + y
    end
    adder
end

add_10 = create_adder(10)
add_10(3) # => 13

Есть встроенные функции высших порядков:

map(add_10, [1,2,3]) # => [11, 12, 13]
filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]

Мы можем использовать для более красивых отображений:

[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]

Типы

Julia имеет систему типов. Каждое значение имеет тип; переменные не имеют типа. Вы можете использовать `typeof` функцию, чтобы получить тип значения.

typeof(5) # => Int64

Types are first-class values:

typeof(Int64) # => DataType
typeof(DataType) # => DataType

DataType это тип, который представляет типы, в том числе себя. Типы используются для документации, оптимизации и диспетчеризации. Они не проверяются статически. Пользователи могут определять типы. Типы похожи на записи или структуры в других языках. Новые типы определяются с помощью ключевого слова `type`.

# type Name
#   field::OptionalType
#   ...
# end

type Tiger
  taillength::Float64
  coatcolor # not including a type annotation is the same as `::Any`
end

Аргументы конструктора по умолчанию являются свойствами типа, в порядке, в котором они перечислены в определении:

tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")

Тип можно использовать как функцию-конструктор для значений этого типа:

sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")

Эти типы-структуры называются конкретные типы. Они могут быть созданы, но не могут иметь подтипы. Другой вид типов абстрактные типы.

# abstract Name
abstract Cat # просто название и объект в иерархии типов

Абстрактные типы не могут быть созданы, но могут иметь подтипы. Например, Number является абстрактным типом:

subtypes(Number) # => 6-element Array{Any,1}:
                 #     Complex{Float16}
                 #     Complex{Float32}
                 #     Complex{Float64}
                 #     Complex{T<:Real}
                 #     ImaginaryUnit
                 #     Real
subtypes(Cat) # => 0-element Array{Any,1}

AbstractString, как следует из названия, также абстрактный тип:

subtypes(AbstractString)    # 8-element Array{Any,1}:
                            #  Base.SubstitutionString{T<:AbstractString}
                            #  DirectIndexString
                            #  RepString
                            #  RevString{T<:AbstractString}
                            #  RopeString
                            #  SubString{T<:AbstractString}
                            #  UTF16String
                            #  UTF8String

Каждый тип имеет родительский тип; используйте функцию `super` для получения родительского типа:

typeof(5) # => Int64
super(Int64) # => Signed
super(Signed) # => Real
super(Real) # => Number
super(Number) # => Any
super(super(Signed)) # => Number
super(Any) # => Any
# Все эти типы, кроме Int64, абстрактные.
typeof("fire") # => ASCIIString
super(ASCIIString) # => DirectIndexString
super(DirectIndexString) # => AbstractString
# Так же и ASCIIString

<: является оператором для создания подтипов:

type Lion <: Cat # Lion подтип Cat
  mane_color
  roar::AbstractString
end

Вы можете определить дополнительные конструкторы для вашего типа. Просто определите функцию с таким же именем, как тип и вызвайте существующий конструктор, чтобы получить значение правильного типа:

Lion(roar::AbstractString) = Lion("green",roar)

Это внешний конструктор, потому что он вне определения типа:

type Panther <: Cat # Panther также подтип Cat
  eye_color
  Panther() = new("зеленая")
  # Panthers будут иметь только этот конструктор и не будут иметь дефолного
end

Использование внутренних конструкторов, как впримере с пантерой, дает вам контроль над тем, как может быть создано значения типа. Когда это возможно, следует использовать внешние конструкторы, а не внутренние.

Множественная Диспетчеризация

В Julia все названные функции - generic функции. Это означает, что они построены из множества маленьких методов. Каждый конструктор для Lion является методом generic функции Lion. Для примера функции не-конструктора, давайте сделаем функцию meow:

#Определение для Lion, Panther, Tiger
function meow(animal::Lion)
  animal.roar # доступ к свойствам типа через точку
end

function meow(animal::Panther)
  "grrr"
end

function meow(animal::Tiger)
  "rawwwr"
end

# Тестирование meow
meow(tigger) # => "rawwr"
meow(Lion("brown","ROAAR")) # => "ROAAR"
meow(Panther()) # => "grrr"

# Обзор локальной иерархии типов
issubtype(Tiger,Cat) # => false
issubtype(Lion,Cat) # => true
issubtype(Panther,Cat) # => true

# Определение функции, принимающей Cat
function pet_cat(cat::Cat)
  println("Кот скаа $(meow(cat))")
end

pet_cat(Lion("42")) # => prints "Кот сказал 42"
try
    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
catch e
    println(e)
end

В ОО языках единичная диспетчеризация; это означает, что метод определяется на основании типа первого аргумента. В Julia все типы аргументов способствуют выбору наилучшего метода. Давайте определим функцию с большим количеством аргументов, чтобы увидеть разницу:

function fight(t::Tiger,c::Cat)
  println("$(t.coatcolor) тигр победил!")
end
# => fight (generic function with 1 method)

fight(tigger,Panther()) # => выведет Оранжевый тигр победил!
fight(tigger,Lion("ROAR")) # => выведет Оранжевый тигр победил!

Давайте изменим поведение, когда Cat конкретно Lion:

fight(t::Tiger,l::Lion) = println("The $(l.mane_color) лев победил!")
# => fight (generic function with 2 methods)

fight(tigger,Panther()) # => выведет Оранжевый тигр победил!
fight(tigger,Lion("ROAR")) # => выведет Зеленый лев победил!

Нам не нужен тигр, чтобы сражаться:

fight(l::Lion,c::Cat) = println("Кот-победитель говорит $(meow(c))")
# => fight (generic function with 3 methods)

fight(Lion("balooga!"),Panther()) # => выведет Кот-победитель говорит grrr
try
  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
catch
end

Так же позволим коту быть первым:

fight(c::Cat,l::Lion) = println("The cat beats the Lion")
# => Warning: New definition
#    fight(Cat,Lion) at none:1
# is ambiguous with
#    fight(Lion,Cat) at none:2.
# Make sure
#    fight(Lion,Lion)
# is defined first.
#fight (generic function with 4 methods)

Предупреждение показано, потому что не понятно, какой метод вызывать:

fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет Кот победитель говорит rarrr

Результат может отличаться в других версиях Julia:

fight(l::Lion,l2::Lion) = println("Львы идут к развязке")
fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет Львы идут к развязке

Вы можете взглянуть на LLVM и сгенерированный ассемблерный код.

square_area(l) = l * l      # square_area (generic function with 1 method)
square_area(5) #25

Что произойдет, когда мы передадим в square_area целое?

code_native(square_area, (Int32,))
    #       .section    __TEXT,__text,regular,pure_instructions
    #   Filename: none
    #   Source line: 1              # Prologue
    #       push    RBP
    #       mov RBP, RSP
    #   Source line: 1
    #       movsxd  RAX, EDI        # Fetch l from memory?
    #       imul    RAX, RAX        # Square l and store the result in RAX
    #       pop RBP                 # Restore old base pointer
    #       ret                     # Result will still be in RAX

code_native(square_area, (Float32,))
    #       .section    __TEXT,__text,regular,pure_instructions
    #   Filename: none
    #   Source line: 1
    #       push    RBP
    #       mov RBP, RSP
    #   Source line: 1
    #       vmulss  XMM0, XMM0, XMM0  # Scalar single precision multiply (AVX)
    #       pop RBP
    #       ret

code_native(square_area, (Float64,))
    #       .section    __TEXT,__text,regular,pure_instructions
    #   Filename: none
    #   Source line: 1
    #       push    RBP
    #       mov RBP, RSP
    #   Source line: 1
    #       vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
    #       pop RBP
    #       ret
    #

Обратите внимание, что Julia будет использовать операции с плавающей точкой, если какой-либо из аргументов float. Давайте вычислиv площадь круга:

circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
circle_area(5)                  # 78.53981633974483

code_native(circle_area, (Int32,))
    #       .section    __TEXT,__text,regular,pure_instructions
    #   Filename: none
    #   Source line: 1
    #       push    RBP
    #       mov RBP, RSP
    #   Source line: 1
    #       vcvtsi2sd   XMM0, XMM0, EDI          # Load integer (r) from memory
    #       movabs  RAX, 4593140240              # Load pi
    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
    #       vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
    #       pop RBP
    #       ret
    #

code_native(circle_area, (Float64,))
    #       .section    __TEXT,__text,regular,pure_instructions
    #   Filename: none
    #   Source line: 1
    #       push    RBP
    #       mov RBP, RSP
    #       movabs  RAX, 4593140496
    #   Source line: 1
    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]
    #       vmulsd  XMM0, XMM1, XMM0
    #       pop RBP
    #       ret
    #

Дальнейшее чтение

Вы можете прочитать намного больше информации в руководстве по Julia (см. Ссылки).

Ссылки