Newer
Older
Ion is the underlying library for shells and command execution in
Redox, as well as the default shell.
[](https://travis-ci.org/redox-os/ion)
[](./LICENSE)
[](https://coveralls.io/github/redox-os/ion?branch=master)
[](https://crates.io/crates/ion-shell)
## Shell Syntax
### Defining Variables
The `let` keyword is utilized to create local variables within the shell. The `export` keyword performs
a similar action, only setting the variable globally as an environment variable for the operating system.
```ion
let git_branch = $(git rev-parse --abbrev-ref HEAD ^> /dev/null)
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
```
If the command is executed without any arguments, it will simply list all available variables.
### Dropping Variables
To drop a value from the shell, the `drop` keyword may be used:
```ion
drop git_branch
```
### Variable Arithmetic
The `let` command also supports basic arithmetic.
```ion
let a = 1
echo $a
let a += 4
echo $a
let a *= 10
echo $a
let a /= 2
echo $a
let a -= 5
echo $a
```
### Export
The `export` command works similarly to the `let` command, but instead of defining a local variable, it defines a global variable that other processes can access.
```ion
export PATH = "~/.cargo/bin:${PATH}"
```
### Export Arithmetic
The `export` command also supports basic arithmetic.
```ion
export a = 1
echo $a
export a += 4
echo $a
export a *= 10
echo $a
export a /= 2
echo $a
export a -= 5
echo $a
```
### Aliases
The `alias` command is used to set an alias for running other commands under a different name. The most common usages of the `alias` keyword are to shorten the keystrokes required to run a command and it's specific arguments, and to rename a command to something more familiar.
```ion
alias ls = 'exa'
```
If the command is executed without any arguments, it will simply list all available aliases.
The `unalias` command performs the reverse of `alias` in that it drops the value from existence.
```ion
unalias ls
```
### Commands
Commands may be written line by line or altogether on the same line with semicolons separating them.
```ion
command arg1 arg2 arg3
command arg1 arg2 arg3
command arg1 arg2 arg3; command arg1 arg2 arg3; command arg1 arg2 arg3
```
The pipe (`|`) and redirect (`>`) operators are used for manipulating the standard output.
```ion
command arg1 | other_command | another_command arg2
command arg1 > file
```
### Piping & Redirecting Standard Error
The `^|` and `^>` operators are used for manipulating the standard error.
```ion
command arg1 ^> file
```
### Piping & Redirecting Both Standard Output & Standard Error
The `&|` and `&>` operators are used for manipulating both the standard output and error.
```ion
command arg1 &| other_command # Not supported yet
command arg1 &> file
```
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
### Conditional Operators
The Ion shell supports the `&&` and `||` operators in the same manner as the Bash shell. The `&&` operator
executes the following command if the previous command exited with a successful exit status. The `||`
operator performs the reverse -- executing if the previous command exited in failure.
```ion
test -e .git && echo Git directory exists || echo Git directory does not exist
```
### If Conditions
It is also possible to perform more advanced conditional expressions using the `if`, `else if`, and `else` keywords.
```ion
let a = 5;
if test $a -lt 5
echo "a < 5"
else if test $a -eq 5
echo "a == 5"
else
echo "a > 5"
end
```
### While Loops
While loops will evaluate a supplied expression for each iteration and execute all the contained statements if it
evaluates to a successful exit status.
```ion
let a = 1
while test $a -lt 100
echo $a
let a += 1
end
```
### For Loops
For loops, on the other hand, will take a variable followed by a list of values or a range expression, and
iterate through all contained statements until all values have been exhausted. If the variable is `_`, it
will be ignored.
```ion
# Obtaining Values From a Subshell
for a in $(seq 1 10)
echo $a
end
# Values Provided Directly
for a in 1 2 3 4 5
echo $a
end
# Exclusive Range
for a in 1..11
echo $a
end
# Inclusive Range
for a in 1...10
echo $a
end
# Ignore Value
for _ in 1..10
do_something
end
```
### Functions
Functions in the Ion shell are defined with a name along with a set of variables. The function
will check if the corrent number of arguments were supplied and execute if all arguments
were given.
```ion
fn fib n
if test $n -le 1
echo $n
else
let output = 1
let previous = 1
let temp = $output
let output += $previous
let previous = $temp
end
echo $output
end
end
for i in 1..20
fib $i
end
### Brace Expansion
It is possible to perform brace expansions within the Ion shell. Currently, only permutation braces are supported.
```ion
echo abc{1,2,3}def{456,789,101112}
```