Язык программирования Кедр. Продолжение

Рассмотрим синтаксис, обработку ошибок, взаимодействие с языком С и возможности реактивного программирования.

Предыдущая статья здесь.

Особенности синтаксиса

val identity = Matrix4 1 0 0 0                        0 1 0 0                        0 0 1 0                        0 0 0 1

Позиционный способ инициализации полей хорошо подходит для матриц. Целочисленный литерал применяется также для вещественных типов чисел.

control.set_width width         set_height control.measure_height         arrange  import num::vector_f32::Vector3                         Vector4             vector_i32::Vector2i

Методы set_width, set_height и arrange вызываются на одной и той же привязке control.

let enabled_extension_names = ["VK_EXT_debug_report"                                "VK_EXT_debug_utils"                                "VK_KHR_surface"                                "VK_KHR_xcb_surface"                                "VK_KHR_xlib_surface"]

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

text |> lines |> filter { line -> line.starts_with "layout" } |> map { remove_comment _ }

Операторы |> удобно располагать в вертикальный ряд. Замыкания создаются с помощью фигурных скобок. Каждое использование подчёркивания возвращает следующий параметр.

let up_right = Vector3 left.as_f32 0 border_z let adjusted_size = size as f32 * 1.5 |> as_u32

Преобразование типа можно записать как вызов метода.

let thickness = (left = border.left                  right = border.right                  up = border.up                  down = border.down)  let sizes = List<(u32, u32) width height>.new

Поля кортежа не имеют имён по умолчанию, обращаться к ним можно только по явно заданным.

Внутристрочное объявление типов

type Entry =     path : String     created : DateTime          | File size : u32     | Directory entries : Slice<Entry>                 | Local                 | Remote url : String

Entry и Directory это типы-суммы, Local и Remote — структуры. Поля path и created доступны как для Entry, так и для каждого из подтипов.

type Entry @abstract = struct     path : String     created : DateTime     is_directory : bool      | File size : u32     | Directory entries : Slice<mut ref Entry>                 is_remote : bool                 | Remote url : String

Структуры File и Directory наследуют поля структуры Entry. Ссылка типа mut ref Entry указывает на File, Directory или Remote.

Классы типов

type Comparable = class     def (>) (rhs : Self) : bool     def (<) (rhs : Self) : bool     def (>=) (rhs : Self) : bool     def (<=) (rhs : Self) : bool  type Compare @virtual =     def compare (other : Self) : Ordering      def (>) (rhs : Self) =         let result = compare rhs         result == Ordering::Greater      ...      is Comparable

Тип может быть объявлен принадлежащим к классу, если соответствует всем заданным для класса ограничениям.

Обработка ошибок

def try_read_file (path : String) : Result<String, String> =     ...  object i32     def try_parse (s : String) : Option<i32> =         ...

Result<String, String> содержит либо прочитанный из файла текст в Ok<String>, либо Error<String> с сообщением об ошибке.

def try_add (lhs_path : String) (rhs : i32) =     let lhs =         let! text = try_read_file lhs_path         let! number = i32.try_parse text         number      lhs + rhs |> Some

Привязки text и number имеют типы String и i32, учитывающие только случаи успешного выполнения функций try_read_file и try_parse.

Ниже показан аналогичный код без let!.

def try_add (lhs_path : String) (rhs : i32) =     let lhs =         let text = case try_read_file lhs_path of             Result::Ok text -> text             Result::Error _ -> return None          let number = case i32.try_parse text of             Some number -> number             None -> return None          number      lhs + rhs |> Some

Полученное от try_read_file сообщение об ошибке можно передать выше по стеку вызовов, вернув Result<i32, String> из try_add вместо Option<i32>.

def try_add (lhs_path : String) (rhs : i32) =     let lhs =         let! text = try_read_file lhs_path         let! number = i32.try_parse text |> to_result "cannot parse $text"         number      lhs + rhs |> Result::Ok

Option конвертируется в Result с помощью метода to_result.

Взаимодействие с языком С

Типы

type VkInstance = MutPtr type CString = Ptr<c_char>

Именованный кортеж с единственным элементом в С коде представлен как тип элемента, поэтому в объявлениях внешних функций VkInstance и CString можно использовать вместо void* и const char*.

typealias DebugUtilsMessengerCallbackExt = fn     (message_severity : DebugUtilsMessageSeverityFlagsExt)     * (message_types : DebugUtilsMessageTypeFlagsExt)     * (callback_data : ptr DebugUtilsMessengerCallbackDataExt)     * (user_data : MutPtr) -> u32  typealias CharFun = fn GlfwWindow * u32 -> Unit

Псевдонимы для типов указателей на функцию.

type SampleCountFlags = flags     | 1     | 2     | 4     | 8     | 16     | 32     | 64

Символы флагов могут быть числами или начинаться с цифры.

type InstanceCreateInfo = struct     type : StructureType     next : Ptr     flags : InstanceCreateFlags     application_info : ptr ApplicationInfo     enabled_layer_count : u32     enabled_layer_names : ptr CString     enabled_extension_count : u32     enabled_extension_names : ptr CString

Структуры переводятся на С дословно.

Значения

object f64     val min "DBL_MIN" : f64     val max "DBL_MAX" : f64     val epsilon "DBL_EPSILON" : f64

Внешние константы DBL_MIN, DBL_MAX и DBL_EPSILON представлены полями объекта f64.

Функции

module vk  def create_semaphore "vkCreateSemaphore"     (device : VkDevice)     (create_info : ptr SemaphoreCreateInfo)     (allocator : Allocator)     (semaphore : mut ptr VkSemaphore) : Result  endmodule

Библиотечная функция vkCreateSemaphore доступна под именем vk::create_semaphore.

def create_semaphore (device : VkDevice) =     let semaphore_create_info = SemaphoreCreateInfo         type = StructureType::SemaphoreCreateInfo         next = null         flags = SemaphoreCreateFlags@zero      let mut semaphore = null     let result = vk::create_semaphore device semaphore_create_info@ptr null                                       semaphore@mut_ptr     assert result == Result::Success      semaphore

Модификаторы @ptr и @mut_ptr возвращают указатель на значение, @fn — указатель на функцию, @zero — обнулённый блок памяти.

type f32     def Real.sin "sinf" : f32     def Real.cos "cosf" : f32     def Real.floor "floorf" : f32     def Real.sqrt "sqrtf" : f32

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

type f64     def Real.sin : f64     def Real.cos : f64     def Real.floor : f64     def Real.sqrt : f64

Функции для f64 уже имеют правильные имена.

Код

В опубликованном коде есть ящики для работы с vulkan и glfw.

Реактивное программирование

type Border =     inherit Control      var obs left : u32 = 0     var obs right : u32 = 0     var obs up : u32 = 0     var obs down : u32 = 0     var obs content : Option<Control> = None

Модификатор obs создаёт контейнер типа mut Atom<T>, поддерживающий публикацию оповещений об изменении значения.

let content_width = content@atom.map     { case _ of           None -> 0           Some control -> control.width }

content@atom вместо значения поля content возвращает контейнер, на котором определена функция map.

let thickness = (border.left@atom                  border.right@atom                  border.up@atom                  border.down@atom)                 |> to_atom

Можно преобразовать кортеж атомов в атом кортежей, thickness имеет тип Atom<(u32, u32, u32, u32)>.

val memory@atom = (content_width, content_height, thickness)                   |> to_atom                   |> map { width, height, thickness ->                       if width == 0 || height == 0                       then None                       else Some (width, height, thickness) }                   |> option_map { width, height, (left, right, up, down) ->                       ...                       MeshMemory.from_quads quads.as_slice }

Из-за модификатора @atom привязка memory имеет тип Option<MeshMemory>, а не Atom<Option<MeshMemory>>.