# Variables

## Variables

* [Values](/jingle-docs/language/variables.md#values)
* [Scope](/jingle-docs/language/variables.md#scope)
* [Assignment](/jingle-docs/language/variables.md#assignment)
* [Variable Types](/jingle-docs/language/variables.md#variable-types)
  * [Variables](/jingle-docs/language/variables.md#variables-1)
  * [Constants](/jingle-docs/language/variables.md#constants)
  * [Typed Variables](/jingle-docs/language/variables.md#typed-variables)
* [Type Declarations](/jingle-docs/language/variables.md#type-declarations)

### Values

*Variables* are named slots for storing values. You define a new variable in Jingle using a `var` statement, like so:

```
var a = 1 + 2
```

 This *declares* a new variable `a` in the current *scope* and initializes it with the result of the expression following the `=`. Once a variable has been defined, it can be accessed by name as you would expect.

```
var animal = "Dog"
echo animal # "Dog"
```

### Scope

Jingle has *block scope*: a variable only exists from where it is define to the end of the block.

```
    echo a # Error: 'a' hasn't been declared yet
    var a = 50 # Declares variable 'a' and assigns value '50'
    echo a # Prints 50
end
echo a # Error: 'a' doesn't exist anymore because it is out of the block
```

 Variables defined at the top level of a script are *top-level* and are visible to the module system. All other variables are *local*. Declaring a variable in an inner scope with the same name as an outer one is called *shadowing* and is not an error (although it’s not something you likely intend to do much).

```
var a = "outer"
: # block opener for example
    var a = "inner"
    echo a # Prints "inner"
end
echo a # Prints "outer"
```

However, *declaring* multiple variables of the same name in the same *scope* is an error.

### Assignment

After a variable has been declared, the value can be reassigned using `=`:

```
var a = 5
a = 6
```

It’s an error to assign to a variable that isn’t defined. This can only be done with variables and binds.

### Variable Types

#### Variables

Variables are dynamically-typed, inferred and mutable. This means you do not have to give it a type, and it can change along with the value of the variable. They are declared with the `var` keyword.

```
# Valid Statements:
var a = 1243
a = 3421

var b = "b"
b = "c"

var c = 2.4
c = 9.9

var d = True
d = False

var e = 50
e = 49.9

var f = "6"
f = 6

var g = True
g = 9 
```

#### Constants

Constants are statically-typed, inferred and immutable. This means you do not have to give it a type, but it cannot change. The value of the variable cannot change. They are declared with the `const` keyword.

```
# Valid Statements:
const GRAVITY = 9.807
const PI = 3.14
const VERSION = 0.1.0

# Invalid Statements:
const MOON = "Moon"
moon = "Sun"
```

#### Typed Variables

Typed Variables are statically-typed, inferred and mutable. This means you do not have to give it a type, but it cannot change. The value of the variable cannot change. They are declared with the `let` keyword.

```
# Valid Statements:
let pizza = 2.99
pizza = 4.99

let fruit = "Apple"
word = "Orange"

# Invalid Statements:
let chicken = "Leg"
chicken = 10

let vegetable = "Cucumber"
vegetable = False
```

### Type Declarations

Types can be deliberately declared using type declarations. They are done like this:

```
var age::int = 20
age = 2.5 # Error, declared as int not float
```

You can declare the type of a variable multiple times:

```
var height::int = 160
height = 180

height::float = 167.5
height = 192.75

height::string = "200"
height = "50" 
```

These can be used for variables if you plan on changing the type of a variable rarely, but still multiple times. If you don't plan on changing the type than just use a typed variable. You can use `bool`,`int`,`float/flt`,`string/str`,`any` in type declarations.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://midoublelo.gitbook.io/jingle-docs/language/variables.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.