# Syntax sugars¶

## Aliases¶

Creating aliases for global variables and functions with cumbersome names can sometimes improve readability. In Taichi, this can be done by assigning kernel and function local variables with `ti.static()`

, which forces Taichi to use standard python pointer assignement.

For example, consider the simple kernel:

```
@ti.kernel
def my_kernel():
for i, j in tensor_a:
tensor_b[i, j] = some_function(tensor_a[i, j])
```

The tensors and function be aliased to new names with `ti.static`

:

```
@ti.kernel
def my_kernel():
a, b, fun = ti.static(tensor_a, tensor_b, some_function)
for i,j in a:
b[i,j] = fun(a[i,j])
```

Aliases can also be created for class members and methods, which can help prevent cluttering objective data-oriented programming code with `self`

.

For example, consider class kernel to compute the 2-D laplacian of some tensor:

```
@ti.kernel
def compute_laplacian(self):
for i, j in a:
self.b[i, j] = (self.a[i + 1,j] - 2.0*self.a[i, j] + self.a[i-1, j])/(self.dx**2) \
+ (self.a[i,j + 1] - 2.0*self.a[i, j] + self.a[i, j-1])/(self.dy**2)
```

Using `ti.static()`

, it can be simplified to:

```
@ti.kernel
def compute_laplacian(self):
a,b,dx,dy = ti.static(self.a,self.b,self.dx,self.dy)
for i,j in a:
b[i,j] = (a[i+1, j] - 2.0*a[i, j] + a[i-1, j])/(dx**2) \
+ (a[i, j+1] - 2.0*a[i, j] + a[i, j-1])/(dy**2)
```

Note

`ti.static`

can also be used in combination with `if`

(compile-time branching) and `for`

(compile-time unrolling). See Metaprogramming for more details.

Here, we are using it for *compile-time const values*, i.e. the **tensor/function handles** are constants at compile time.