Странный синтаксис!: Константы Юлии

Странный синтаксис!

Странный синтаксис!: Константы Юлии

Еще немного интересного синтаксиса Джулии: юлианские константы.

введение

Если вы хоть раз в жизни занимались программированием или занимались базовой алгеброй, то вы, вероятно, знаете, что такое переменная. Переменная — это значение, которое вводится в пространство некоторых чисел для выполнения арифметических действий и, что более важно; быть изменены и иметь вариации. Хотя переменная является важным и ключевым значением, существуют также различные типы данных, которые могут быть частью их выборки или анализа данных, и это использование констант.

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

что странного в константах?

Хотя в константах нет ничего странного по своей сути, существует много действительно интересного синтаксиса, который можно создать с помощью констант. Как и следовало ожидать, любая константа может быть использована в качестве аргумента, если функция не изменяет тип. Поэтому есть несколько довольно интересных способов использования констант, один из которых — довольно новое дополнение к Джулии!

константы в конструкторах

С выпуском Julia 1.8 у нас теперь есть доступ к новой функции Julia, которая позволяет нам обозначать отдельные поля структуры как константы. Это означает, что теперь у нас может быть mutable struct, внутри которого все еще содержатся статические значения. Неизменяемые данные, безусловно, имеют свое место, и легко понять, почему может быть вариант использования чего-то вроде смешанного типа, в котором некоторые значения могут быть изменены, а некоторые — неизменны. Например, мы хотим сделать идентификационный номер для группы студентов, и каждая метка должна быть постоянной, потому что мы определенно не хотим, чтобы идентификационный номер менялся.

Это довольно новое дополнение не только полезно, но и невероятно просто в использовании! Начните с исходного конструктора Julia:

mutable struct Student
   id::Int64
   name::String
end

Мы можем сделать поля постоянными, просто добавив const перед объявлением любого из этих полей.

mutable struct Student
   const id::Int64
   name::String
end

Довольно легко, правда?!

Излишне говорить, что это очень долгожданное дополнение к языку, и я очень рад, что оно реализовано. Существует так много разных вариантов использования конструктора смешанного изменения, такого как этот, и я рад видеть, к чему сообщество Джулии теперь применяет это. Кроме того, если вам нужно краткое изложение некоторых основных моментов выпуска Julia 1.8, я написал целую статью на эту тему, которую вы можете прочитать здесь:

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

константы как экспорт

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

julia> pi
π = 3.1415926535897...

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

julia> 2pi
6.283185307179586

Точно так же мы можем сделать то же самое с другими нашими константами, такими как моя новая константа the_sun.

julia> const the_sun = 5000
5000
julia> 2the_sun
10000

То же самое можно было бы сделать, если бы это была переменная, а не константа,

julia> the_sun = 5000
5000
julia> 2the_sun
10000

Во что это можно манипулировать? Самая популярная реализация высокоуровневого синтаксиса, которую я видел, включает Measures.jl . Этот пакет использует константы для создания синтаксиса измерения для предоставления чисел. Каждая константа на самом деле является AbsoluteLength , которую Джулия затем может интерпретировать в графические измерения. На первом этапе этого подхода мы создадим новый тип MeasurementSymbol.

mutable struct MeasurementSymbol{P <: Any} end

Последняя статья Странный синтаксис!, которую я написал, на самом деле была основана на этой концепции, поэтому, если вы хотите немного познакомиться, вот ссылка на эту статью!:

Этот тип является лишь прикрытием для использования нами параметрического символизма для отправки нашего MeasurementSymbol . Теперь нам нужно импортировать оператор * из Base.

import Base: *

Это позволит нам добавлять к этому оператору новые методы. Метод, который мы собираемся добавить, будет отправлять умножение с Int64 для получения желаемого результата в пикселях, который в данном случае будет просто String с буквами px и числом внутри него.

*(i::Int64, ms::MeasurementSymbol{:px}) = "$(i)px"

Теперь нам просто нужно сделать нашу константу…

const px = MeasurementSymbol{:px}()

Наконец, мы можем использовать эту константу так же, как и раньше с pi.

5px
"5px"

заключение

В Джулии есть много действительно крутых вещей, которые можно сделать с константами. Синтаксис измерения, безусловно, потрясающий, поскольку он действительно может создать синтаксис гораздо более высокого уровня, чем многие другие доступные варианты. Этому даже способствуют обычные варианты использования констант. И затем, наконец, точка затаптывается всякий раз, когда у нас также есть константы в качестве полей. Что еще круче, так это то, что мы не ограничены традиционной алгеброй или вариантами использования благодаря множественной диспетчеризации и расширяемости языка Julia. В целом, я нахожу эту реализацию констант чрезвычайно привлекательной. Спасибо за чтение!