2. Tip Sistemi

---

§6 Types

Programlar değerler hesaplar. WGSL'de bir tip (type), bir değerler kümesidir ve her değer tam olarak bir tipe aittir. Bir değerin tipi, o değer üzerinde gerçekleştirilebilecek operasyonların sözdizimini ve semantiğini belirler.

Örneğin, matematiksel 1 sayısı WGSL'de şu farklı değerlere karşılık gelir:

WGSL bunları farklı değerler olarak ele alır çünkü makine temsilleri ve operasyonları farklıdır.

Bir tip ya predeclared (önceden bildirilmiş) ya da WGSL kaynağında bir declaration ile oluşturulur.

Bazı tipler template parameterization olarak ifade edilir. Bir type-generator, template list ile parametrelendirildiğinde bir tip gösteren predeclared nesnedir. Örneğin atomic<u32>, atomic type-generator'ını <u32> template list'i ile birleştirir.

Bazı WGSL tipleri yalnızca kaynak program analizi ve çalışma zamanı davranışının belirlenmesi için kullanılır; WGSL kaynak metninde görünmez.

---

6.1 Type Checking

Bir WGSL değeri bir expression (ifade) değerlendirilerek hesaplanır. Expression, WGSL grammar kurallarından adı "expression" ile biten biridir. Bir expression E, kendisi içinde yer alan subexpression'lar içerebilir.

Bir expression değerlendirmesinin ürettiği değer şunlara bağlıdır:

• Static context: İfadeyi çevreleyen kaynak metin.
• Dynamic context: İfadeyi değerlendiren invocation'ın durumu ve çalıştırma bağlamı.

Belirli bir ifadenin değerlendirmesinden çıkabilecek değerler her zaman belirli bir WGSL tipine ait olup bu tip ifadenin static type'ıdır. Static type yalnızca static context'e bağlıdır.

Bir type assertion e : T, "*T*, WGSL ifadesi e'nin static type'ıdır" demektir. Bu bir runtime kontrolü değil, program metni hakkında bir olgudur.

Type checking, başarıyla parse edilmiş bir WGSL modülündeki her ifadeyi static type'ına eşleme ve her statement'ın tip gereksinimlerini doğrulama sürecidir. Başarısız olursa type error (bir tür shader-creation error) oluşur.

WGSL statically typed bir dildir: type checking yalnızca program kaynak metnini inceleyerek başarılı olur veya type error bulur.

6.1.1 Type Rule Tables

WGSL'in type rule'ları, ifadeler için type rule table'lara organize edilir (satır başına bir rule). Bir type rule iki parçadan oluşur:

• Conclusion — İfade için type assertion (veya statement için birden fazla type assertion).
• Preconditions — Subexpression'lar için type assertion'lar, statement'ın sözdizimsel formu ve diğer koşullar.

Parameterized type rule, type parameter içerir. Belirli tipler substitution ile atanarak fully elaborated rule elde edilir. Her olası substitution bir overload üretir.

Örneğin, mantıksal negasyon !e type rule'u:

Bu parameterized rule'un 4 overload'u vardır (bool, vec2<bool>, vec3<bool>, vec4<bool>).

Bir syntactic phrase analiz edilirken üç durum olabilir: 1. Hiçbir type rule uygulanmaz → type error. 2. Tam bir fully elaborated rule uygulanır → static type belirlenir. 3. Birden fazla rule uygulanır → overload resolution (§6.1.3) ile çözülür.

6.1.2 Conversion Rank

Bir type assertion e: T precondition olarak kullanıldığında şu durumlarda karşılanır:

• e zaten T tipindeyse, veya
• e, S tipindeyse ve S'den T'ye feasible automatic conversion varsa.

ConversionRank(Src, Dest) fonksiyonu, bir tipten diğerine otomatik dönüşümün tercih edilirliğini ve uygulanabilirliğini ifade eder. Düşük rank daha tercih edilirdir.

Concretization: T tipi S'nin concretization'ıdır eğer T concrete ise, reference type değilse, ConversionRank(S,T) sonlu ise ve başka hiçbir concrete non-reference T2 tipi için ConversionRank(S,T2) ≤ ConversionRank(S,T) değilse.

6.1.3 Overload Resolution

Birden fazla type rule bir syntactic phrase'e uygulandığında, overload resolution ile bağ çözülür:

1. Her overload candidate C için, her subexpression i konumundaki ConversionRank C.R(i) hesaplanır. 2. Subexpression'lardan biri abstract tipe resolve olurken diğeri const-expression değilse, o candidate elimine edilir. 3. C1, C2'ye preferred ise:

4. Tek bir preferred candidate varsa overload resolution başarılı olur; yoksa başarısız olur → type error.

• Her i için C1.R(i) ≤ C2.R(i), ve
• En az bir i için C1.R(i) < C2.R(i).

Örnekler:

// log2(32): AbstractInt 32 → AbstractFloat'a dönüştürülür, sonuç AbstractFloat.
let x = log2(32);

// 1 + 2.5: AbstractInt 1 → AbstractFloat 1.0'a dönüşüm (rank 5,0 → kazanır),
// sonuç AbstractFloat.
let y = 1 + 2.5;

// let x = 1 + 2.5: x abstract olamaz, f32 veya f16 kandidatları kalır,
// f32 tercih edilir. Sonuç: let x: f32 = 1.0f + 2.5f;
let z = 1 + 2.5;

// 1u + 2.5: u32'den float'a feasible conversion yok → shader-creation error.

---

6.2 Plain Types

Plain type, boolean, sayı, vektör, matris veya bu değerlerin bileşimlerinin makine temsili için kullanılan tiplerdir.

Plain type = scalar | atomic | composite type.

6.2.1 Abstract Numeric Types

Bu tipler WGSL kaynağında yazılamaz; yalnızca type checking tarafından kullanılır. Belirli ifadeler shader-creation time'da, GPU'nun doğrudan implemente ettiğinden daha geniş bir sayısal aralık ve hassasiyetle değerlendirilir.

• Abstract numeric tipdeki bir expression değerlendirmesi overflow yapmamalı, sonsuz veya NaN değer üretmemelidir.
• Abstract tip: abstract numeric tip içeren veya olan tip. Concrete tip: abstract olmayan tip.

Suffix'siz literal'lar abstract numeric tiplere karşılık gelir:

• Suffix'siz integer literal (123) → AbstractInt
• Suffix'siz float literal (1.5) → AbstractFloat

// Explicitly-typed
var u32_1 = 1u;     // u32
var i32_1 = 1i;     // i32
var f32_1 = 1f;     // f32

// Inferred — abstract → concrete
let some_i32 = 1;           // → i32 (en tercih edilen: rank 3)
var u32_from_type: u32 = 1; // → u32
var f32_promotion: f32 = 1; // → f32

// Invalid
var i32_demotion: i32 = 1.0; // AbstractFloat → i32 dönüşüm yok!

6.2.2 Boolean Type

bool tipi true ve false değerlerini içerir.

6.2.3 Integer Types

Concrete integer tiplerdeki overflow eden ifadeler, sonucu modulo 2^bitwidth üretir.

6.2.4 Floating Point Types

Extreme değerler (pozitif):

6.2.5 Scalar Types

Scalar tipler: bool, AbstractInt, AbstractFloat, i32, u32, f32, f16.

Alt grupları:

• Numeric scalar: AbstractInt, AbstractFloat, i32, u32, f32, f16
• Integer scalar: AbstractInt, i32, u32

Scalar conversion, bir scalar tipteki değeri farklı bir scalar tipe eşler. Şu yollarla gerçekleşir:

• Açık value constructor çağrısı.
• Abstract numeric tipten başka bir tipe feasible automatic conversion yoluyla.

6.2.6 Vector Types

Vector, 2, 3 veya 4 scalar bileşenden oluşan gruplanmış bir dizidir.

vec2<f32>  // 2 bileşenli f32 vektörü
vec3<i32>  // 3 bileşenli i32 vektörü

Kullanım alanları: yön + büyüklük, uzayda konum, renk temsili (RGBA).

Birçok vektör (ve matris) operasyonu component-wise çalışır:

let x: vec3<f32> = a + b; // a, b vec3<f32>
// x[0] = a[0] + b[0]
// x[1] = a[1] + b[1]
// x[2] = a[2] + b[2]

Predeclared vector alias'ları:

6.2.7 Matrix Types

Matrix, 2, 3 veya 4 floating point vektörden oluşan gruplanmış bir dizidir.

mat2x3<f32> // 2 sütun, 3 satır f32 matrisi
            // Eşdeğer: 2 adet vec3<f32> sütun vektörü.

Temel kullanım: lineer dönüşüm. Çarpım operatörü (*) ile:

• Scalar ile ölçekleme
• Vektöre dönüşüm uygulama
• Matris birleştirme

Predeclared matrix alias'ları:

6.2.8 Atomic Types

Atomic type, concrete integer scalar tipi kapsülleyerek eşzamanlı gözlemcilere belirli garantiler sağlar.

Kurallar:

• Bir expression atomic tipe evaluate olmamalıdır.
• Atomic tipler yalnızca workgroup address space'deki değişkenlerde veya read_write erişim modlu storage buffer değişkenlerinde instantiate edilebilir.
• workgroup address space → memory scope Workgroup.
• storage address space → memory scope QueueFamily.
• Geçerli operasyonlar yalnızca atomic builtin function'lardır.
• Atomic modification: atomic nesnenin içeriğini ayarlayan herhangi bir operasyon. Yeni değer mevcut değerle aynı olsa bile modification sayılır.
• Atomic modification'lar her nesne için mutually ordered'dır.

6.2.9 Array Types

Array, indeksli bir eleman değerleri dizisidir. İlk eleman index 0'dadır.

**Fixed-size array N kısıtlamaları:**

• N, override-expression olmalıdır.
• Concrete integer scalar tipe evaluate etmelidir.
• N ≤ 0 ise:
• const-expression ise → shader-creation error
• Değilse → pipeline-creation error

Runtime-sized array eleman sayısı, ilişkili storage buffer binding'in boyutuna göre belirlenir.

**Eleman tipi E kısıtlamaları:**

• Plain, constructible veya fixed-footprint tipte olmalıdır.
• Runtime-sized array, struct'ın son üyesinde veya doğrudan storage buffer variable türü olarak kullanılabilir.

array<f32, 4>     // 4 elemanlı f32 dizisi
array<vec3<f32>>  // runtime-sized vec3<f32> dizisi

6.2.10 Structure Types

Structure (struct), her biri adı ve tipine sahip bir veya daha fazla member'dan oluşan, isimlendirilen bir tipdir.

struct PointLight {
  position : vec3f,
  color    : vec3f,
}

struct LightStorage {
  pointCount : u32,
  point      : array<PointLight>,
}

Kurallar:

• Her struct struct keyword'ü ile bilddirilir.
• Bir WGSL modülünde aynı struct adı en fazla bir kez bildirilebilir.
• İki farklı struct declaration'ı aynı yapıda member'lara sahip olsa bile farklı tiplerdir (nominal typing).
• Üyeler bildirim sırasına göre indekslidir (ilk üye = index 0).
• Member erişimi .member_name ile yapılır.
• Struct'lar doğrudan veya dolaylı olarak kendi kendine referans veremez (öz-referanslı yapılar yasaktır).

6.2.11 Composite Types

Composite type, bileşenlerden oluşan tiplerdir:

• Vector — component'ları scalar.
• Matrix — component'ları vector (veya column olarak bakıldığında: scalar'lar).
• Array — element'leri.
• Structure — member'ları.

Her composite tip, bileşenlerine erişim ve doğrudan veya dolaylı olarak scalar tiplerine ulaşmayı sağlar.

Nesting depth kavramı: Scalar/atomic = 0; composite tipte 1 + max(bileşenlerin derinliği). Maximum nesting depth: 15.

6.2.12 Constructible Types

Constructible type, let, const veya value constructor ile değer oluşturulabilen tiplerdir:

• bool
• Integer scalar tipler: i32, u32
• Floating point scalar tipler: f32, f16
• Constructible component tipli vektörler
• Constructible column tipli matrisler
• Constructible eleman tipli fixed-size array'ler
• Tüm üyeleri constructible olan struct'lar

Constructible olmayan tipler: atomic<T>, runtime-sized array, constructible olmayan üyeye sahip struct.

6.2.13 Fixed-Footprint Types

Fixed-footprint tip, boyutu yalnızca tipine göre belirlenen tipdir (runtime bilgisine bağlı değil):

• Scalar tipler, vektörler, matrisler, atomic tipler
• Fixed-size array (element count const-expression ise)
• Tüm üyeleri fixed-footprint olan struct'lar

Creation-fixed footprint: element count override-expression veya const-expression ise. Override-sized array: element count const-expression olmayan override-expression ise.

---

6.3 Enumeration Types

Enumeration type, ayrık (discrete) değerler kümesidir. Enum'ın her bir değeri bir enumerant value'dur.

Bazı enum tipler predeclared olup WGSL kaynak metninde yazılamaz:

• address_space — Adres alanı (function, private, workgroup, uniform, storage, handle)
• access_mode — Erişim modu (read, write, read_write)
• texel_format — Texel biçimi (rgba8unorm, rgba16float, r32float vb.)

6.3.1 Predeclared Enumerants

Address Space enumerant'ları:

Access Mode enumerant'ları:

Texel Format enumerant'ları:

---

6.4 Memory Views

Bellek görünümü tipleri, bellekte saklanan değerlere erişim biçimlerini tanımlar. Bellek görünümü, saklama, paylaşma ve erişim mekanizmalarını kapsar.

6.4.1 Storable Types

Storable type, bellekte saklanabilen tiplerdir. Tüm plain tipler (atomic, constructible vb.) ve saklama desteği olan tipler storable'dır.

Storable tip: plain type veya texture/sampler tipi.

6.4.2 Host-shareable Types

Host-shareable type, GPU ile CPU arasında paylaşılabilen tiplerdir. uniform ve storage address space'lerdeki değişkenlerin tipleri host-shareable olmalıdır.

Host-shareable tipler:

• Scalar tipler (abstract olmayan): i32, u32, f32, f16
• Atomic tipler
• Host-shareable component tipli vektörler
• Host-shareable column tipli matrisler
• Host-shareable eleman tipli fixed-size array'ler
• Tüm üyeleri host-shareable olan struct'lar

Bellekteki yerleşim (layout), alignment ve size kurallarına tabidir. @align ve @size attribute'ları ile kontrol edilebilir.

6.4.3 Reference and Pointer Types

WGSL'de değişkenler bellekte yer kaplar. Belirli bir bellek konumuna erişmek için iki tip vardır:

Parametreler:

• AS: address space (function, private, workgroup, uniform, storage)
• T: stored type (saklanacak tip)
• AM: access mode (read, write, read_write)

Reference tipler otomatik olarak oluşturulur: bir değişken adı kullanıldığında ortaya çıkan ifade bir reference'tır. Load Rule, readable reference'tan değer okumak için otomatik olarak uygulanır.

var x: f32 = 1.0;     // x'in tipi: ref<function, f32, read_write>
let value = x;         // Load Rule uygulanır → value: f32
let p = &x;            // p'nin tipi: ptr<function, f32, read_write>
let value2 = *p;       // Pointer dereference → Load Rule → f32

6.4.4 Valid and Invalid Memory References

Valid memory reference: referansın işaret ettiği bellek konumunun anlamlı değerler barındırması garanti edilen referans.

Invalid memory reference: geçersiz referanslara erişim WGSL tarafından tanımsız davranış değildir — bunun yerine güvenli varsayılan davranışlar uygulanır.

• Array sınırı dışı erişim → sınır içine normalize edilir (clamp).
• Geçersiz pointer → implementasyon tarafından iyi tanımlanmış bir sonuç üretir.

6.4.5 Originating Variable

Her reference veya pointer'ın bir originating variable'ı vardır — bu, referansın nihayetinde işaret ettiği kök değişkendir.

Kurallar:

• Bir fonksiyona pointer parametresi geçirildiğinde, originating variable korunur.
• İki pointer, aynı originating variable'a sahip olmalıdır — aksi durumda birlikte kullanılamazlar.

6.4.6 Out-of-Bounds Access

Dinamik olarak belirlenen bir indeks ile diziye erişildiğinde, indeks sınır dışındaysa davranış:

• Okuma: [0, N-1] aralığına clamp edilir (N = eleman sayısı). Sonuç, dizinin geçerli bir elemanının değeridir.
• Yazma: [0, N-1] aralığına clamp edilir. Geçerli bir elemana yazma gerçekleşir.
• Bu, hafıza güvenliğini garanti eder ama mantıksal hatayı gizleyebilir.

var arr: array<f32, 4>;
let idx = 10u;
let val = arr[idx]; // idx clamp → arr[3]

6.4.7 Use Cases for References and Pointers

Reference kullanım alanları:

• Değişkenin değerini okuma (Load Rule otomatik uygulanır).
• Değişkene atama (sol tarafta kullanım).
• Compound assignment (x += 1).
• Atomic built-in fonksiyon çağrıları.

Pointer kullanım alanları:

• Fonksiyonlara bellek konumu geçirme (pass-by-reference semantiği).
• Referansı saklama ve sonra kullanma.
• Struct veya array üyesine dolaylı erişim.

fn increment(p: ptr<function, i32>) {
  *p += 1;
}

fn main() {
  var counter: i32 = 0;
  increment(&counter);
  // counter artık 1
}

6.4.8 Forming Reference and Pointer Values

Reference ve pointer değerleri oluşturma yolları:

Kısıtlamalar:

• let ile bildirilen pointer'lar yalnızca function ve private address space'lere işaret edebilir.
• Pointer'a pointer oluşturulamaz (çift indirection yok).
• Pointer, global scope'ta let ile bildirilemez.

6.4.9 Comparison with References and Pointers in Other Languages

---

6.5 Texture and Sampler Types

Texture ve sampler tipleri, yaygın GPU rendering donanımını WGSL'de kullanıma açar. Her ikisi de opaque tiplerdir — yalnızca handle olarak kullanılır, iç yapılarına doğrudan erişilemez.

Texture, GPU belleğindeki çok boyutlu veri dizisidir. Sampler, texture'ın nasıl örnekleneceğini (sample) tanımlar: filtreleme, adres sarmalama vb.

Her ikisi de handle address space'te bulunur ve pipeline creation sırasında binding ile ilişkilendirilir.

6.5.1 Texel Formats

Texel format, bir texel'in (texture element) bellek düzenini tanımlar. Storage texture'lar belirli bir texel formatı belirtmelidir.

Her texel formatına karşılık gelen bir channel format ve texel type vardır. Texel type, built-in fonksiyonlarda dönüş veya parametre tipi olarak kullanılır.

6.5.2 Sampled Texture Types

Sampled texture, shader'da örnekleme veya yükleme (load) ile okunur. Texel component tipi T, f32, i32 veya u32 olmalıdır.

6.5.3 Multisampled Texture Types

Multisampled texture, her texel'de birden fazla sample barındırır (anti-aliasing için).

6.5.4 External Sampled Texture Types

6.5.5 Storage Texture Types

Storage texture'lar, texel formatı ve erişim modunu açıkça belirtir. Shader tarafından okunabilir veya yazılabilir.

• F: texel format (rgba8unorm, r32float vb.)
• A: access mode (read, write, read_write)

6.5.6 Depth Texture Types

Depth texture'lar derinlik bilgisi saklar. Component tipi f32'dir.

6.5.7 Sampler Type

Sampler, texture örneklemesinde filtreleme ve adres sarmalama gibi parametreleri tanımlar.

---

6.6 AllTypes Type

AllTypes, tüm WGSL tiplerinin üst kümesidir. Bu bir kavramsal çerçevedir ve kaynak metninde yazılmaz. Type rule'larda, bir parametrenin herhangi bir tip olabileceğini belirtmek için kullanılır.

---

6.7 Type Aliases

Type alias, mevcut bir tipe yeni bir isim verir. Alias, orijinal tipin tam eşdeğeridir (nominal olarak farklı değildir).

alias float4 = vec4<f32>;
alias Arr = array<i32, 5>;

// Kullanım
var color: float4;
var data: Arr;

type_alias_decl :
  'alias' ident '=' type_specifier

Type alias'lar sadece modül scope'ta bildirilebilir. Bir alias, tanımlandıktan sonra görünür hale gelir. Döngüsel alias zinciri (A → B → A) yasaktır ve shader-creation error üretir.

---

6.8 Type Specifier Grammar

Tip belirtme (type specifier), bir tipi kaynak metninde ifade etmenin sözdizimsel yoludur.

type_specifier :
  | ident template_elaborated_ident

Bir type specifier, ya doğrudan bir tip adıdır ya da template list ile parametrelendirilmiş bir formda yazılır:

f32                  // Basit tip adı
vec3<f32>            // Template parametreli tip
array<vec2<f32>, 4>  // İç içe template parametreler

---

6.9 Predeclared Types and Type-Generators Summary

Tüm predeclared tiplerin ve type-generator'ların özet tablosu:

---