High-level DSL with operator overloading for natural syntax. Provides literals, arithmetic, comparison, and other operators that compile to type-safe WGSL expressions.

def Hesper.WGSL.litF32 (f : Float) : Exp (WGSLType.scalar ScalarType.f32)

Create an f32 literal

Equations

• Hesper.WGSL.litF32 f = Hesper.WGSL.Exp.litF32 f

def Hesper.WGSL.litF16 (f : Float) : Exp (WGSLType.scalar ScalarType.f16)

Create an f16 literal

Equations

• Hesper.WGSL.litF16 f = Hesper.WGSL.Exp.litF16 f

def Hesper.WGSL.litI32 (i : Int) : Exp (WGSLType.scalar ScalarType.i32)

Create an i32 literal

Equations

• Hesper.WGSL.litI32 i = Hesper.WGSL.Exp.litI32 i

def Hesper.WGSL.litU32 (u : Nat) : Exp (WGSLType.scalar ScalarType.u32)

Create a u32 literal

Equations

• Hesper.WGSL.litU32 u = Hesper.WGSL.Exp.litU32 u

def Hesper.WGSL.litBool (b : Bool) : Exp (WGSLType.scalar ScalarType.bool)

Create a bool literal

Equations

• Hesper.WGSL.litBool b = Hesper.WGSL.Exp.litBool b

def Hesper.WGSL.lit (f : Float) : Exp (WGSLType.scalar ScalarType.f32)

Convenience function: Create f32 literal (most common type)

Equations

• Hesper.WGSL.lit f = Hesper.WGSL.litF32 f

def Hesper.WGSL.var {t : WGSLType} (name : String) : Exp t

Create a variable reference

Equations

• Hesper.WGSL.var name = Hesper.WGSL.Exp.var name

instance Hesper.WGSL.instHAddExp_1 {t : WGSLType} : HAdd (Exp t) (Exp t) (Exp t)

Addition operator for WGSL expressions

Equations

• Hesper.WGSL.instHAddExp_1 = { hAdd := Hesper.WGSL.Exp.add }

instance Hesper.WGSL.instHSubExp_1 {t : WGSLType} : HSub (Exp t) (Exp t) (Exp t)

Subtraction operator for WGSL expressions

Equations

• Hesper.WGSL.instHSubExp_1 = { hSub := Hesper.WGSL.Exp.sub }

instance Hesper.WGSL.instHMulExp_1 {t : WGSLType} : HMul (Exp t) (Exp t) (Exp t)

Multiplication operator for WGSL expressions

Equations

• Hesper.WGSL.instHMulExp_1 = { hMul := Hesper.WGSL.Exp.mul }

instance Hesper.WGSL.instHDivExp_1 {t : WGSLType} : HDiv (Exp t) (Exp t) (Exp t)

Division operator for WGSL expressions

Equations

• Hesper.WGSL.instHDivExp_1 = { hDiv := Hesper.WGSL.Exp.div }

instance Hesper.WGSL.instHModExp_1 {t : WGSLType} : HMod (Exp t) (Exp t) (Exp t)

Modulo operator for WGSL expressions

Equations

• Hesper.WGSL.instHModExp_1 = { hMod := Hesper.WGSL.Exp.mod }

instance Hesper.WGSL.instNegExp {t : WGSLType} : Neg (Exp t)

Negation operator for WGSL expressions

Equations

• Hesper.WGSL.instNegExp = { neg := Hesper.WGSL.Exp.neg }

def Hesper.WGSL.divExp {t : WGSLType} (a b : Exp t) : Exp t

Integer division for WGSL expressions (./.)

Equations

• Hesper.WGSL.divExp a b = a.div b

def Hesper.WGSL.modExp {t : WGSLType} (a b : Exp t) : Exp t

Modulo for WGSL expressions (./.)

Equations

• Hesper.WGSL.modExp a b = a.mod b

instance Hesper.WGSL.instOfNatExpScalarF32 {n : Nat} : OfNat (Exp (WGSLType.scalar ScalarType.f32)) n

Equations

• Hesper.WGSL.instOfNatExpScalarF32 = { ofNat := Hesper.WGSL.litF32 (OfNat.ofNat n) }

instance Hesper.WGSL.instOfNatExpScalarI32_1 {n : Nat} : OfNat (Exp (WGSLType.scalar ScalarType.i32)) n

Equations

• Hesper.WGSL.instOfNatExpScalarI32_1 = { ofNat := Hesper.WGSL.litI32 (OfNat.ofNat n) }

instance Hesper.WGSL.instOfNatExpScalarU32_1 {n : Nat} : OfNat (Exp (WGSLType.scalar ScalarType.u32)) n

Equations

• Hesper.WGSL.instOfNatExpScalarU32_1 = { ofNat := Hesper.WGSL.litU32 n }

instance Hesper.WGSL.instCoeNatExpScalarU32 : Coe Nat (Exp (WGSLType.scalar ScalarType.u32))

Equations

• Hesper.WGSL.instCoeNatExpScalarU32 = { coe := fun (n : Nat) => Hesper.WGSL.litU32 n }

instance Hesper.WGSL.instCoeIntExpScalarI32 : Coe Int (Exp (WGSLType.scalar ScalarType.i32))

Equations

• Hesper.WGSL.instCoeIntExpScalarI32 = { coe := fun (i : Int) => Hesper.WGSL.litI32 i }

instance Hesper.WGSL.instCoeFloatExpScalarF32 : Coe Float (Exp (WGSLType.scalar ScalarType.f32))

Equations

• Hesper.WGSL.instCoeFloatExpScalarF32 = { coe := fun (f : Float) => Hesper.WGSL.litF32 f }

instance Hesper.WGSL.instCoeBoolExpScalarBool : Coe Bool (Exp (WGSLType.scalar ScalarType.bool))

Equations

• Hesper.WGSL.instCoeBoolExpScalarBool = { coe := fun (b : Bool) => Hesper.WGSL.litBool b }

instance Hesper.WGSL.instCoeStringExp {t : WGSLType} : Coe String (Exp t)

Equations

• Hesper.WGSL.instCoeStringExp = { coe := fun (s : String) => Hesper.WGSL.Exp.var s }

class Hesper.WGSL.WGSLEq (α : Type) : Type

Custom equality class for WGSL expressions

• weq : α → α → Exp (WGSLType.scalar ScalarType.bool)
• wne : α → α → Exp (WGSLType.scalar ScalarType.bool)

class Hesper.WGSL.WGSLOrd (α : Type) : Type

Custom ordering class for WGSL expressions

• wlt : α → α → Exp (WGSLType.scalar ScalarType.bool)
• wle : α → α → Exp (WGSLType.scalar ScalarType.bool)
• wgt : α → α → Exp (WGSLType.scalar ScalarType.bool)
• wge : α → α → Exp (WGSLType.scalar ScalarType.bool)

instance Hesper.WGSL.instWGSLEqExp {t : WGSLType} : WGSLEq (Exp t)

Equations

• Hesper.WGSL.instWGSLEqExp = { weq := Hesper.WGSL.Exp.eq, wne := Hesper.WGSL.Exp.ne }

instance Hesper.WGSL.instWGSLOrdExp {t : WGSLType} : WGSLOrd (Exp t)

Equations

• Hesper.WGSL.instWGSLOrdExp = { wlt := Hesper.WGSL.Exp.lt, wle := Hesper.WGSL.Exp.le, wgt := Hesper.WGSL.Exp.gt, wge := Hesper.WGSL.Exp.ge }

def Hesper.WGSL.«term_.==._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.==._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.==._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .==. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.!=._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.!=._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.!=._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .!=. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.<._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.<._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.<._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .<. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.<=._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.<=._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.<=._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .<=. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.>._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.>._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.>._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .>. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.>=._» : Lean.TrailingParserDescr

Equations

• Hesper.WGSL.«term_.>=._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.>=._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .>=. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.&&._» : Lean.TrailingParserDescr

Boolean AND

Equations

• Hesper.WGSL.«term_.&&._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.&&._» 35 35 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .&&. ") (Lean.ParserDescr.cat `term 36))

def Hesper.WGSL.«term_.||._» : Lean.TrailingParserDescr

Boolean OR

Equations

• Hesper.WGSL.«term_.||._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.||._» 30 30 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .||. ") (Lean.ParserDescr.cat `term 31))

def Hesper.WGSL.«term.!._» : Lean.ParserDescr

Boolean NOT

Equations

• Hesper.WGSL.«term.!._» = Lean.ParserDescr.node `Hesper.WGSL.«term.!._» 40 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol ".!.") (Lean.ParserDescr.cat `term 40))

def Hesper.WGSL.«term_.<<._» : Lean.TrailingParserDescr

Bitwise left shift

Equations

• Hesper.WGSL.«term_.<<._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.<<._» 60 60 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .<<. ") (Lean.ParserDescr.cat `term 61))

def Hesper.WGSL.«term_.>>._» : Lean.TrailingParserDescr

Bitwise right shift

Equations

• Hesper.WGSL.«term_.>>._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.>>._» 60 60 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .>>. ") (Lean.ParserDescr.cat `term 61))

def Hesper.WGSL.«term_.&._» : Lean.TrailingParserDescr

Bitwise AND

Equations

• Hesper.WGSL.«term_.&._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.&._» 55 55 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .&. ") (Lean.ParserDescr.cat `term 56))

def Hesper.WGSL.«term_.|._» : Lean.TrailingParserDescr

Bitwise OR

Equations

• Hesper.WGSL.«term_.|._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.|._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .|. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.«term_.^._» : Lean.TrailingParserDescr

Bitwise XOR

Equations

• Hesper.WGSL.«term_.^._» = Lean.ParserDescr.trailingNode `Hesper.WGSL.«term_.^._» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " .^. ") (Lean.ParserDescr.cat `term 51))

def Hesper.WGSL.toF32 {t : WGSLType} (e : Exp t) : Exp (WGSLType.scalar ScalarType.f32)

Convert to f32

Equations

• f32(e) = e.toF32

def Hesper.WGSL.toF16 {t : WGSLType} (e : Exp t) : Exp (WGSLType.scalar ScalarType.f16)

Convert to f16

Equations

• f16(e) = e.toF16

def Hesper.WGSL.toI32 {t : WGSLType} (e : Exp t) : Exp (WGSLType.scalar ScalarType.i32)

Convert to i32

Equations

• i32(e) = e.toI32

def Hesper.WGSL.toU32 {t : WGSLType} (e : Exp t) : Exp (WGSLType.scalar ScalarType.u32)

Convert to u32

Equations

• u32(e) = e.toU32

def Hesper.WGSL.«termF32(_)» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Hesper.WGSL.«termF16(_)» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Hesper.WGSL.«termI32(_)» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Hesper.WGSL.«termU32(_)» : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Hesper.WGSL.term_!_ : Lean.TrailingParserDescr

Array indexing operator

Equations

• Hesper.WGSL.term_!_ = Lean.ParserDescr.trailingNode `Hesper.WGSL.term_!_ 90 90 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ! ") (Lean.ParserDescr.cat `term 91))

def Hesper.WGSL.vecX {st : ScalarType} (v : Exp (WGSLType.vec2 st)) : Exp (WGSLType.scalar st)

Vector component accessors

Equations

• Hesper.WGSL.vecX v = v.vecX

def Hesper.WGSL.vecY {st : ScalarType} (v : Exp (WGSLType.vec2 st)) : Exp (WGSLType.scalar st)

Equations

• Hesper.WGSL.vecY v = v.vecY

def Hesper.WGSL.vecZ {st : ScalarType} (v : Exp (WGSLType.vec3 st)) : Exp (WGSLType.scalar st)

Equations

• Hesper.WGSL.vecZ v = v.vecZ

def Hesper.WGSL.vecW {st : ScalarType} (v : Exp (WGSLType.vec4 st)) : Exp (WGSLType.scalar st)

Equations

• Hesper.WGSL.vecW v = v.vecW

def Hesper.WGSL.mkVec2 {st : ScalarType} (x y : Exp (WGSLType.scalar st)) : Exp (WGSLType.vec2 st)

Create vec2

Equations

• Hesper.WGSL.mkVec2 x y = x.vec2 y

def Hesper.WGSL.mkVec3 {st : ScalarType} (x y z : Exp (WGSLType.scalar st)) : Exp (WGSLType.vec3 st)

Create vec3

Equations

• Hesper.WGSL.mkVec3 x y z = x.vec3 y z

def Hesper.WGSL.mkVec4 {st : ScalarType} (x y z w : Exp (WGSLType.scalar st)) : Exp (WGSLType.vec4 st)

Create vec4

Equations

• Hesper.WGSL.mkVec4 x y z w = x.vec4 y z w

def Hesper.WGSL.sqrt' {t : WGSLType} (e : Exp t) : Exp t

Square root

Equations

• Hesper.WGSL.sqrt' e = e.sqrt

def Hesper.WGSL.abs' {t : WGSLType} (e : Exp t) : Exp t

Absolute value

Equations

• Hesper.WGSL.abs' e = e.abs

def Hesper.WGSL.min' {t : WGSLType} (a b : Exp t) : Exp t

Minimum of two values

Equations

• Hesper.WGSL.min' a b = a.min b

def Hesper.WGSL.max' {t : WGSLType} (a b : Exp t) : Exp t

Maximum of two values

Equations

• Hesper.WGSL.max' a b = a.max b

def Hesper.WGSL.clamp' {t : WGSLType} (e lo hi : Exp t) : Exp t

Clamp value between min and max

Equations

• Hesper.WGSL.clamp' e lo hi = e.clamp lo hi

def Hesper.WGSL.exp' {t : WGSLType} (e : Exp t) : Exp t

Exponential function

Equations

• Hesper.WGSL.exp' e = e.exp

def Hesper.WGSL.sin' {t : WGSLType} (e : Exp t) : Exp t

Sine function

Equations

• Hesper.WGSL.sin' e = e.sin

def Hesper.WGSL.cos' {t : WGSLType} (e : Exp t) : Exp t

Cosine function

Equations

• Hesper.WGSL.cos' e = e.cos

def Hesper.WGSL.pow' {t : WGSLType} (base exponent : Exp t) : Exp t

Power function

Equations

• Hesper.WGSL.pow' base exponent = base.pow exponent

def Hesper.WGSL.tanh' {t : WGSLType} (e : Exp t) : Exp t

Hyperbolic tangent

Equations

• Hesper.WGSL.tanh' e = e.tanh

def Hesper.WGSL.select' {t : WGSLType} (cond : Exp (WGSLType.scalar ScalarType.bool)) (ifTrue ifFalse : Exp t) : Exp t

Select between two values based on condition (WGSL select function)

Equations

• Hesper.WGSL.select' cond ifTrue ifFalse = cond.select ifTrue ifFalse

Example Usage

-- Create variables
def x : Exp (.scalar .f32) := Exp.var "x"
def y : Exp (.scalar .f32) := Exp.var "y"

-- Natural arithmetic syntax
def expr1 := x + y * 2.0  -- Multiplication binds tighter

-- Comparisons
def cond := x .>. 0.0 .&&. y .<. 10.0

-- Type conversions
def asInt := i32(x)

-- Math functions
def length := sqrt'(x * x + y * y)

-- Conditional
def result := select' (x .>. 0.0) x (-x)  -- absolute value

def Hesper.WGSL.sqrt (x : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Square root

Equations

• Hesper.WGSL.sqrt x = x.sqrt

def Hesper.WGSL.abs (x : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Absolute value

Equations

• Hesper.WGSL.abs x = x.abs

def Hesper.WGSL.min (x y : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Minimum of two values

Equations

• Hesper.WGSL.min x y = x.min y

def Hesper.WGSL.max (x y : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Maximum of two values

Equations

• Hesper.WGSL.max x y = x.max y

def Hesper.WGSL.exp (x : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Exponential function

Equations

• Hesper.WGSL.exp x = x.exp

def Hesper.WGSL.clamp (x minVal maxVal : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Clamp value to range

Equations

• Hesper.WGSL.clamp x minVal maxVal = x.clamp minVal maxVal

def Hesper.WGSL.pow (x y : Exp (WGSLType.scalar ScalarType.f32)) : Exp (WGSLType.scalar ScalarType.f32)

Power function

Equations

• Hesper.WGSL.pow x y = x.pow y

def Hesper.WGSL.select {t : WGSLType} (cond : Exp (WGSLType.scalar ScalarType.bool)) (trueVal falseVal : Exp t) : Exp t

Select (ternary operator): select(cond, trueVal, falseVal)

Equations

• Hesper.WGSL.select cond trueVal falseVal = cond.select trueVal falseVal

def Hesper.WGSL.matLoadLeft {st : ScalarType} {m k : Nat} (ptrRef : String) (offset stride : Exp (WGSLType.scalar ScalarType.u32)) (transpose : Exp (WGSLType.scalar ScalarType.bool) := litBool false) : Exp (WGSLType.subgroupMatrixLeft st m k)

Load subgroup matrix (left operand) from buffer

Equations

• Hesper.WGSL.matLoadLeft ptrRef offset stride transpose = Hesper.WGSL.Exp.subgroupMatrixLoad ptrRef offset transpose stride

def Hesper.WGSL.matLoadRight {st : ScalarType} {k n : Nat} (ptrRef : String) (offset stride : Exp (WGSLType.scalar ScalarType.u32)) (transpose : Exp (WGSLType.scalar ScalarType.bool) := litBool false) : Exp (WGSLType.subgroupMatrixRight st k n)

Load subgroup matrix (right operand) from buffer

Equations

• Hesper.WGSL.matLoadRight ptrRef offset stride transpose = Hesper.WGSL.Exp.subgroupMatrixLoadRight ptrRef offset transpose stride

def Hesper.WGSL.matMulAcc {st : ScalarType} {m k n : Nat} (a : Exp (WGSLType.subgroupMatrixLeft st m k)) (b : Exp (WGSLType.subgroupMatrixRight st k n)) (acc : Exp (WGSLType.subgroupMatrixResult st m n)) : Exp (WGSLType.subgroupMatrixResult st m n)

Multiply-accumulate for subgroup matrices

Equations

• Hesper.WGSL.matMulAcc a b acc = a.subgroupMatrixMultiplyAccumulate b acc

def Hesper.WGSL.matStore {st : ScalarType} {m n : Nat} (ptrRef : String) (offset : Exp (WGSLType.scalar ScalarType.u32)) (mat : Exp (WGSLType.subgroupMatrixResult st m n)) (stride : Exp (WGSLType.scalar ScalarType.u32)) (transpose : Exp (WGSLType.scalar ScalarType.bool) := litBool false) : Exp (WGSLType.scalar ScalarType.u32)

Store subgroup matrix result to buffer

Equations

• Hesper.WGSL.matStore ptrRef offset mat stride transpose = Hesper.WGSL.Exp.subgroupMatrixStore ptrRef offset mat transpose stride

def Hesper.WGSL.matZeroLeft {st : ScalarType} {m k : Nat} : Exp (WGSLType.subgroupMatrixLeft st m k)

Zero-initialized subgroup matrix (left)

Equations

• Hesper.WGSL.matZeroLeft = Hesper.WGSL.Exp.subgroupMatrixZeroLeft

def Hesper.WGSL.matZeroRight {st : ScalarType} {k n : Nat} : Exp (WGSLType.subgroupMatrixRight st k n)

Zero-initialized subgroup matrix (right)

Equations

• Hesper.WGSL.matZeroRight = Hesper.WGSL.Exp.subgroupMatrixZeroRight

def Hesper.WGSL.matZeroResult {st : ScalarType} {m n : Nat} : Exp (WGSLType.subgroupMatrixResult st m n)

Zero-initialized subgroup matrix (result)

Equations

• Hesper.WGSL.matZeroResult = Hesper.WGSL.Exp.subgroupMatrixZeroResult

def Hesper.WGSL.barrier : Exp (WGSLType.scalar ScalarType.u32)

Workgroup barrier

Equations

• Hesper.WGSL.barrier = Hesper.WGSL.Exp.workgroupBarrier

def Hesper.WGSL.get {elemTy : WGSLType} {n : Nat} (arr : Exp (elemTy.array n)) (idx : Exp (WGSLType.scalar ScalarType.u32)) : Exp elemTy

Index into an array

Equations

• arr[idx] = arr ! idx

def Hesper.WGSL.«term_[_]» : Lean.TrailingParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Hesper.WGSL.atomicAdd {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically add to i32, returns old value

Equations

• Hesper.WGSL.atomicAdd ptr value = ptr.atomicAdd value

def Hesper.WGSL.atomicAddU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically add to u32, returns old value

Equations

• Hesper.WGSL.atomicAddU ptr value = ptr.atomicAddU value

def Hesper.WGSL.atomicSub {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically subtract from i32, returns old value

Equations

• Hesper.WGSL.atomicSub ptr value = ptr.atomicSub value

def Hesper.WGSL.atomicSubU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically subtract from u32, returns old value

Equations

• Hesper.WGSL.atomicSubU ptr value = ptr.atomicSubU value

def Hesper.WGSL.atomicMin {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically compute minimum with i32, returns old value

Equations

• Hesper.WGSL.atomicMin ptr value = ptr.atomicMin value

def Hesper.WGSL.atomicMinU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically compute minimum with u32, returns old value

Equations

• Hesper.WGSL.atomicMinU ptr value = ptr.atomicMinU value

def Hesper.WGSL.atomicMax {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically compute maximum with i32, returns old value

Equations

• Hesper.WGSL.atomicMax ptr value = ptr.atomicMax value

def Hesper.WGSL.atomicMaxU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically compute maximum with u32, returns old value

Equations

• Hesper.WGSL.atomicMaxU ptr value = ptr.atomicMaxU value

def Hesper.WGSL.atomicExchange {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically exchange (swap) i32 value, returns old value

Equations

• Hesper.WGSL.atomicExchange ptr value = ptr.atomicExchange value

def Hesper.WGSL.atomicExchangeU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically exchange (swap) u32 value, returns old value

Equations

• Hesper.WGSL.atomicExchangeU ptr value = ptr.atomicExchangeU value

def Hesper.WGSL.atomicCompareExchangeWeak {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicI32))) (compare value : Exp (WGSLType.scalar ScalarType.i32)) : Exp (WGSLType.scalar ScalarType.i32)

Atomically compare-and-exchange i32 (weak version), returns old value

Equations

• Hesper.WGSL.atomicCompareExchangeWeak ptr compare value = ptr.atomicCompareExchangeWeak compare value

def Hesper.WGSL.atomicCompareExchangeWeakU {space : MemorySpace} (ptr : Exp (WGSLType.ptr space (WGSLType.scalar ScalarType.atomicU32))) (compare value : Exp (WGSLType.scalar ScalarType.u32)) : Exp (WGSLType.scalar ScalarType.u32)

Atomically compare-and-exchange u32 (weak version), returns old value

Equations

• Hesper.WGSL.atomicCompareExchangeWeakU ptr compare value = ptr.atomicCompareExchangeWeakU compare value