Система типов

Tags:

• Типы Данных
• ООП
• Коллекции
• Обощения

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

Такой подход напоминает иерархию типов в языке Java, в котором каждый класс имеет в своих родителях класс java.lang.Object. И точно так же как в Java, примитивные типы данных в TrustLang с динамоческой типизации минимальным прототипом класса будет

public String toString()

Возвращает строковое представление объекта.

public native int hashCode() public boolean equals(Object obj)

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

public final native Class getClass()

Возвращает специальный объект, который описывает текущий класс.

public final native void notify() public final native void notifyAll() public final native void wait(long timeout) public final void wait(long timeout, intnanos) public final void wait()

Методы для контроля доступа к объекту из различных нитей. Управление синхронизацией нитей.

protected void finalize()

Метод позволяет «освободить» родные не-Java ресурсы: закрыть файлы, потоки и т.д.

protected native Object clone()

С помощью обобщений и шаблонов можно писать код, который может работать с любым совместимым типом данных.

Фрагмент иерархии типов данных (строки и числа, а в скобках указаны синонимы типов):

Нужно ли тенхоры включать в систему типов? Или это толкьо формат хранения. Но в этом случае комплексные числа тоже будут фомартами хранения или все же отдельным типом?

:Any -+-> :Arithmetic -+-> :Tensor -+-> :Integer --> :Int64   ...  --> :Int8 --> :Bool
      |                |            |               (:DWord64)        (:Char)
      |                |            |                                 (:Byte)
      |                |            |
      |                |            +-> :Number --> :Float64 --> :Float32 --> :Float16 --> ...
      |                |            |              (:Double)    (:Single)
      |                |            |
      |                |            +-> :Complex ...
      |                | 
      |                +-> :Rational
      | 
      +-> :String -+-> :StrChar
      |            |  (:FmtChar)
      |            |
      |            +-> :StrWide
      |               (:FmtWide)
      |            
      |
     ...


:Any -+-> :Collection -+-> :Tensor ---> Array
      |                | 
      |                +-> :Dictionary ---> Array

Числовые типы в Julia

     Any
    └── Number
    ├── Complex{T}
    └── Real
        ├── AbstractFloat  (Float16, Float32, Float64)
        ├── Integer
        │   ├── Bool
        │   ├── Signed     (Int8, Int16, Int32, Int64, Int128)
        │   └── Unsigned   (UInt8, UInt16, UInt32, UInt64, UInt128)
        └── Rational{T}

Обобщенные типы

• :Any - обобщенный тип для всех остальных типов данных
• :Arithmetic - обобщенный тип для всех числовых типов
• :Collection - обобщенный тип для всех видов коллекций
• :Tensor - обобщенный тип для всех коллекций машинных типов
• :Array - обобщенный тип для всех одномерным коллекций машинных типов
• :Tensor - обобщенный тип для чисел, которые можно представить в машинном формате
• :Integer - обощенный тип для всех целочисленных типов данных
• :Number - обощенный тип для всех чисел с плавающей точкой
• :Complex - обощенный тип для всех комплексных чисел
• :String - обощенный тип для текстовых строк

BaseType

ExtraType (для упрощения и оптимизации) Scalar -> Tensor[0] Array -> Tensor[1] String (general) -> (StrChar-> Array:Char, StrWide -> Array:Int32) Format (general) -> (FmtChar-> StrChar, FmtWide -> StrWide)

Any -> Arithmetic -> Integer = :Int64 … –> :Int8 –> :Bool -> Number -> Complex -> Rational

-> Container    -> Dict
                -> Set
                -> Tensor   -> Array (Tensor[1])    ->   Scalar (Tensor[0])
                -> String (StrChar, StrWide) 

Any -> Arithmetic -> (Integer, Number, Complex, Rational) Container -> (Dictionary, Array, Tensor, String)

Any -> Tensor -> Array -> String (StrChar, StrWide) -> Dictionary -> Set -> Plain -> (Enum, Struct, Union, Optional)

Чистые функции или pure functions — это функции, которые при вызове не влияют на состояние программы и не имеют побочных эффектов. Они возвращают значения только на основе входных аргументов и не изменяют их. Признаки чистых функций:

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

Чистота функции контролируется компилятором, но во время выполнения чистая функция ничем не отличается от обычной функции.

Execution Function Corutine

pure() :- { } # Чистая функция (обычная функция во время выполнения) func() := { } # Обычная функция без сохранения состояние между вызовами coro() := { }; # Сохраняет состояние между вызовами

Thread( func: Function ) # функция выполняется в отдельном потоке Async( coro: Corutine ) # Поток выполнения переключается в одном потоке между всеми корутинами ThreadPool( thread: Thread ) # Балансирует нагрузку между потоками

Пул потоков с асинхронными обработчиками (асинхронная матрешка) ThreadPool( Thread( Async( { } ) ) )

:Any -+-> :Arithmetic -+-> :Tensor -+-> :Integer --> :Int64   ...  --> :Int8 --> :Bool
      |                |            |               (:DWord64)        (:Char)
      |                |            |                                 (:Byte)
      |                |            |
      |                |            +-> :Number --> :Float64 --> :Float32 --> :Float16 --> ...
      |                |            |              (:Double)    (:Single)
      |                |            |
      |                |            +-> :Complex ...
      |                | 
      |                +-> :Rational
      | 
      +-> :String -+-> :StrChar
      |            |  (:FmtChar)
      |            |
      |            +-> :StrWide
      |               (:FmtWide)
      |            
      |
     ...

Примеры определения функций с обобщенными типами

    only_int8(arg:Int8):Int8 :=  ... ;   # Функиця принимает и возвращает только :Int8

    any_int(arg:Integer):Integer :=  ... ;  # Функиця принимает и возвращает только целые числа

    any_tensor(arg:Tensor):Tensor :=  ... ;# Функиця принимает и возвращает любые машинные типы чисел
    
    any_any1(arg:Any):None :=  ... ; # Функиця принимает любой тип аргумента и ничего не возвращает 

    any_any_not(arg:<:Arithmetic-:Rational-:Complex>):None :=  ... ; # Функиця принимает любые числа, кроме рациональьных и комплексных и ничего не возвращает 
    any_any_or(arg:<:Integer+:Number>):None :=  ... ; # Функиця принимает только целые числа и числа с плавающей точкой и ничего не возвращает 

    any_any2(arg) :=  ... ;     # Тип не указан - функиця можен принимать и возвращать любой тип