Terra

app (/int4, /var) x = 42
app (/intbyte, /const) limit = 255
app (/int8-, /var) signed_val = -100   ! знаковий: суфікс "-"
app (/int4, /var) nothing = .None.    ! ініціалізація нулем

app (/intbyte, /var) a = 0b1100   ! двійковий = 12
app (/intbyte, /var) b = 0o14    ! вісімковий = 12
app (/intbyte, /var) c = 0xC     ! шістнадцятковий = 12

app (/float,    /var) f32  = 3.14159       ! 32-bit
app (/d-float,  /var) f64  = 2.718281828   ! 64-bit double
app (/float16,  /var) f16  = 1.5           ! 16-bit half
app (/q-float,  /var) f128 = 1.41421356   ! 128-bit quad

! Hex формат (alpha = 255 за замовчуванням)
app (/color, /var) green = #A4C639

! Hex з альфою
app (/color, /var) semi = #A4C63980

! RGB числами (0-255, alpha=255)
app (/color, /var) blue = 0, 0, 255

! RGB + alpha (0.0–1.0 → 0–255)
app (/color, /var) fade = 0, 0, 255, 0.155

/display(C)             ! 164, 198, 57, 255
/display(C(.hex.))      ! #A4C639
/display(C(.hex.a.))   ! #A4C639FF
/display(C(.rgb.))      ! 164, 198, 57
/display(C(.rgb.a.))   ! 164, 198, 57, 255
/display(C(.a.))        ! 255 (тільки alpha)

app (/color, /var) C = #A4C639

::start::
! Один канал
C::Red + (10)

! Кілька каналів в одному рядку (через кому)
C::Red + (10), Green - (5), Blue * (2)

! З saturation (&st)
C::Red + (100)&st, Alpha - (50)&st

app (/color, /var) C = #A4C639
app (/color, /var) D = #FF0000

::start::
! Векторна арифметика color + color (поканально)
C (C + D)
C (C - D)

! Color + скаляр (до кожного каналу)
C (C + 10)
C (C * 2)

! З saturation
C (C + D)&st

app (/color, /var) C = #A4C639

::start::
C* + (10)   ! всі 32 біти RGBA як одне i32
C* / (2)    ! lshr i32 (бітовий зсув вправо)
C* * (2)    ! shl i32 (бітовий зсув вліво)

app (/shelf, /intbyte, /var) S = (1, 2, 3, 4, 5)
app (/shelf, /int4-, /var)   T = (-10, 0, 10, 20)  ! знаковий

! СИНТАКСИС (не реалізовано в парсері)
app (/raster[8][4], /intbyte, /var) R

::start::
x (42)          ! присвоїти 42
x (y)           ! присвоїти значення y
x + (10)        ! x = x + 10
x - (3)         ! x = x - 3
x * (2)         ! x = x * 2
x / (4)         ! x = x / 4
x (a + b)      ! x = a + b (вирази зліва направо!)

y copy x   ! y ← копія x (семантика значення)

x + (300)&st    ! якщо x=100 → 255 (не wrap)
x * (10)&st    ! clamp до max типу

! Інші модифікатори результату:
x + (5)&min   ! зберегти мінімум
x + (5)&max   ! зберегти максимум

<<! (x)   ! x = 0 (через бітовий зсув, оптимальний IR)
<<! (S)   ! весь shelf = 0 (тільки unsigned shelf)

! Math теги — застосовуються до shelf
/sum(S)          ! сума всіх елементів
/mean(S)         ! середнє арифметичне
/max(S)          ! максимальне значення
/min(S)          ! мінімальне значення
/sqrt(x)         ! квадратний корінь (float)
/margin(x)       ! відхилення від середнього

S[2] + (10)       ! S[2] = S[2] + 10
S* + (5)          ! всі елементи + 5
S* * (2)          ! всі елементи * 2

! При оголошенні нового shelf:
app (/shelf, /intbyte, /var) Left  = S[-1]  ! rotate left 1
app (/shelf, /intbyte, /var) Right = S[+1]  ! rotate right 1

! S = (1,2,3,4,5)
! Left  → (5,1,2,3,4)
! Right → (2,3,4,5,1)

! S = (1,2,3,4,5,6,7,8,9)
app (/shelf, /intbyte, /var) M  = /mirror(S)
! M → (9,8,7,6,5,4,3,2,1)

app (/shelf, /intbyte, /var) M2 = /mirror(S(/s_half))
! M2 → (5,4,3,2,1,6,7,8,9) — дзеркало першої половини

! S = (1,2,3,4,5,6,7,8,9)
app (/shelf, /intbyte, /var) D1 = /difference(S(step::1))
! D1 → (1,1,1,1,1,1,1,1) — різниця між кожним

app (/shelf, /intbyte, /var) D2 = /difference(S(step::2))
! D2 → (2,2,2,2,2,2,2) — через один

! Ripple = (0,0,0,0,0,0,0,0,0,0,0,0,0)
::start::
/ripple(Ripple(step::3(3), count::+1))[2] + (4)
! → (0,0,4,4,4,5,5,5,6,6,6,0,0)
!    ↑крок 3, 3 групи, +1 між групами, стартова позиція [2]

! Shelf=(1,2,3,4,5)  Shelf1=(0,0,0,0,0)
Shelf2 (Shelf ++ Shelf1)           ! 1,2,3,4,5,0,0,0,0,0
Shelf2 (Shelf ++ Shelf1(step::1))   ! 1,0,2,0,3,0,4,0,5,0
Shelf2 (Shelf(step::1) ++ Shelf1)   ! 0,1,0,2,0,3,0,4,0,5

/display(S)              ! всі елементи
/display(S[2])           ! елемент [2]
/display(S(.name.))     ! ім'я shelf ("S")
/display(/map(S))        ! карта індекс→значення
/display(/mean(S))      ! середнє значення

app (/shelf, /intbyte, /var) S = (0,1,2,3,4,5,6,7,8)

::start::
! Оголошуємо аліас для індексів [1,0,8]
S[*1*0*8] (aliasing::Alise)

! Далі звертаємось по імені:
Alise + (10)     ! S[1]+=10, S[0]+=10, S[8]+=10
Alise (42)       ! присвоєння пакету

! Оголошення контракту (умови для елементів)
app (/elseif) Filter:
    < .True. ({int}, 5, /intbyte)   ! елемент < 5
    = .True. ({int}, 5, /intbyte)   ! елемент = 5
    > .True. ({int}, 5, /intbyte)   ! елемент > 5

app (/shelf, /intbyte, /var) S = (1,2,3,4,5,6,7,8,9)

! perform: гілки обробки по умовах
perform Jenni()(S)(Filter):
    .True. = S.N(Filter(<, =, >(.N.))),(+10)/(*5)/(−4)&rw
    end Jenni
!                              ↑<5  ↑=5  ↑>5
!                                   операції для кожної гілки

::start::
call Jenni()()():

! perform Назва()(параметри)(ElseIf):
perform Calc()(x, y)():
    x + (1)
    y * (2)
    end Calc

::start::
call Calc()(a, b)():   ! передати конкретні змінні

perform GetVal()(src)():
    src + (10)
    return src       ! передає значення в onlyread приймач
    end GetVal

! Оголошення: чиста трансформація без побічних ефектів
app (/cross-block) cb:
    __enter = 2          ! кількість вхідних аргументів
    __out   = 1          ! кількість вихідних аргументів
    __type  = /intbyte  ! тип елементів
    cross.0 (__enter.0 + __enter.1)  ! проміжний результат
    __out.0 (cross.0 * 2)&st          ! вихідний результат
    end cb

! Оголошення змінних
app (/intbyte, /var) result = .None.
app (/intbyte, /var) a = 10
app (/intbyte, /var) b = 20

! Виклик: call name(inputs)(outputs):
::start::
call cb(a, b)(result):
/display(result)  ! 60

! /left, /right — векторизовані операції між сусідніми блоками
! (синтаксис спроектовано, реалізація в процесі)
app (/cross-block) ShiftLeft:
    __enter = 8
    __out   = 8
    __type  = /intbyte
    __out.0 (__enter.0 /left (1))
    end ShiftLeft

! Виклик Python stdlib — значення присвоюється через &Python
app (/intbyte, /var) Intbyte = .None.

::start::
Intbyte (randint(12, 18))&Python   ! ціле від 12 до 18
/display(Intbyte)

/display(x)       ! за типом
/display(x(B))    ! binary  → 0b101010
/display(x(O))    ! octal   → 0o52
/display(x(F))    ! hex     → 0x2A
/display(x(*))    ! decimal (примусово)

::start::
::time::               ! старт RDTSC
x + (1)
x * (2)
/display(UA(::end_time::))   ! стоп + вивід укр.
! → "Час виконання операції: XXXXX тактів процесора"

/display(EN(::end_time::))   ! або англ.
! → "Execution time: XXXXX CPU cycles"

! Групові права — список функцій через кому
app (/intbyte, /var) x = 100 limit::(Jenni, Ginny)&r

! Індивідуальні права
app (/intbyte, /var) y = 200 limit::Jenni&rw

! Комбінація: група тільки-читати + один читати-писати
app (/intbyte, /var) z = 200 limit::(Jenni, Ginny)&r, Astra&rw

! Ексклюзивний приймач — тільки конкретна функція
app (/intbyte, /onlyread) jenni_excl = ( .Jenni. )

! Будь-яка perform функція може читати
app (/intbyte, /onlyread) any_fn = ( .perform. )

! Без обмежень (всі функції мають доступ)
app (/intbyte, /var) public = 150

app (/intbyte, /var) temp = 42
app (/intbyte, /var) pressure = 50

app (/mainwindow) Main:
    /size = 400x300
    /background = (20, 20, 20)
    app (/label(style::DANGER)) templabel = (temp)
    app (/label) presslabel = (pressure)&mm_color((100+, #E32636), (5-, (93, 138, 168)))
    app (/button(style::PRIMARY)) resetbtn = Main.reset("Reset")
perform .reset ()(temp, pressure)():
    temp + (0)
    end .reset
    end Main

::start::
Main.return

! Простий label
app (/label) lbl = (x)

! З іменованим стилем
app (/label(style::DANGER)) lbl = (temp)

! Червоний якщо значення >= 129 (перескочило поріг 128)
app (/label) lbl = (int1)&max_color(128+, #E32636)

! Те саме але кольор через змінні
app (/label) lbl = (int1)&max_color(stopline+, color_value)

! Синій якщо значення <= 128
app (/label) lbl = (int1)&min_color(128-, #E32636)

! Обидва пороги одночасно: >=100 червоний, <=5 синій
app (/label) lbl = (pressure)&mm_color((100+, #E32636), (5-, (93, 138, 168)))

! Числові значення shelf
app (/label, /shelf) shelf_lbl = (S)

! Кольорові квадратики замість чисел
app (/label, /shelf) shelf_lbl = (S)&color_data

! Числа у кольорових квадратиках (потребує style)
app (/label, /shelf(style::ENDS)) shelf_lbl = (S)&data

! Тільки квадратики зі стилем
app (/label, /shelf(style::ENDS)) shelf_lbl = (S)&color_data

! Звичайна кнопка
app (/button) btn = Main.click("Click me!")

! З іменованим стилем
app (/button(style::PRIMARY)) resetbtn = Main.reset("Reset")

style::/label(DANGER)
    /border(5pt)              ! товщина бордера
    /border(5pt, #E32636)    ! + колір бордера
    /background(#1E1E1E)     ! фон hex ✅
    /max_color(128+, #E32636)
    /min_color(10-, #0088FF)
    /mm_color((128+, #E32636), (10-, #0088FF))

style::/label(WAVE)
    /wave(/background(#E32636, #00DDDD))        ! анімація за замовчуванням
    /wave(/background(#E32636, #00DDDD), stop)   ! статична хвилька
    /wave(/background(#E32636, #00DDDD), 18)     ! швидкість 18 пт/сек

style::/label(ENDS)
    /color_data(0...5(#FF9966), 6...255(127, 255, 0))
    ! значення 0-5 → помаранчевий квадрат
    ! значення 6-255 → зелений квадрат

style::/button(PRIMARY)
    /border(2pt)
    /background(#FFFFFF)

app (/intbyte, /var) counter = 0

app (/mainwindow) Main:
    /size = 400x300
    /background = (20, 20, 20)
    app (/label) lbl = (counter)
    app (/button) btn = Main.click("Click me!")
perform .click ()(counter)():
    counter + (1)
    /display(counter)
    end .click
    end Main

::start::
Main.return