I am trying to find some simpler syntax for variable type converters. In my scripts, I have been declaring variables for controlling the behavior like this:

```
FFT_Size = 128
```

I may then use this variable to control loops, create arrays, etc. The problem is that the numbers are treated as floats and I need them to be integers. For example in C, if I assign a float to an int, it will auto truncate the value. In many cases I need to divide this control variable by an integer.

For example:

```
Data = Array{Complex64}(convert(UInt32,floor(FFT_Size/2)))
```

I would like to simple do something like this:

```
Data = Array{Complex64}(FFT_Size/2)
```

In this case I am simple trying initialize an array of complex numbers with a length of the FFT_Size. I am sure there is a *much* simpler way of achieving this.

It does not seem like globals can have a type assigned like this:

```
FFT_Size::UInt32
```

Lastly it seems if I doing something like this:

```
a = 128::Int
```

the expression

```
a/2 or a/2::Int
```

will always yield a Float64

I often have to create new arrays where the length is dependent on some prior computation. Maybe I am simply approaching this incorrectly?