my_var: int128 = 101
my_another_var: int64 = my_var as int64

if my_var is int64:
    print("Это неправда")
elif my_var as int64 is int64:
    print("Сработает")

# Объявление типа
type fInt = func<int> -> int

def do_stuff(x: int, callback: fInt) -> int:
    x ^= 2
    x = callback(x)
    return x

num = do_stuff(3,
    def (y: int) -> int:
        y += 7
        return y
)

print(
    num
)

# Замыкание
def start_at(x: int) -> fInt:
    def increment_by(y: int) -> int:
        return x + y
    return increment_by

start_at_5 = start_at(5)
start_at_27 = start_at(27)

print(start_at_5(4))
print(start_at_27(15))

# Ввод данных пользователем
age: int = input('Сколько вам лет?')

# Интерполяция строк
print('Ого! Вам {age} лет?!')

# Перегрузка операторов
def operator - (x: int, y:int) -> int  # Два параметра перегружают бинарные операции
    return x + 3

def operator - (x: int) -> int  # Один параметр перегружает бинарные операции
    return 0 - x + 1

# Внешние функции (FFI)
def extern abs(x: int) -> int # из C's stdlib

print(abs(-5.0 as int)) # по умолчанию в Lesma целые числа — это int64, а в C — int32

# или вы можете просто позволить Lesma преобразовывать между «совместимыми» типами, такими как числа
print(abs(-5.0))

# Именованные параметры и значения по умолчанию
def optional_params(x: int, y: int32 = 5, z: double = 9) -> int:
    # Lesma заботится о приведении возвращаемого типа между «совместимыми» типами
    return x + z

optional_params(5, z=11)

def defer_demo()
    defer print("World!")
    print("Hello")

defer_demo() # выводит Hello World!

# Типы enum
enum Color
    GREEN
    RED
    BLUE
    YELLOW

x: Colors = Color.GREEN
print(x == Color.GREEN)

# Структуры
struct Circle
    radius: int
    x: int
    y: int = 4

cir: Circle = Circle(radius=5, x=2)

print(cir.radius)

# Классы
class Vehicle
    # Конструктор
    def new(year: int, color: str)
        self.year = year
        self._color = color

# Наследование
class Car: Vehicle
    def new(year: int, color='green', hatchback=false)
        self.hatchback = hatchback
        super.Vehicle(year, color)

    def print_year() -> void:
        print('Этот автомобиль был сделан в {self.year}')

ford = Car(1992)

print(ford.hatchback)
ford.print_year()

# Универсальные шаблоны

# Пропустите тип и назначьте уникальный универсальный тип для каждого параметра
def basicGeneric(a, b)
    print(a)
    print(b)

# Используя нотацию <T>, компилятор следит за тем, чтобы используемые типы совпадали, если они повторяются среди параметров и/или возвращаемого типа
def typedGeneric<T>(a: T, b: T) -> T:
    return a

# У типов могут быть ограничения, и эти ограничения могут быть Traits, Classes, Structs или Enums
def complexGeneric<T: AdditionTrait>(a: T, b: T) -> T:
    return a + b