Rosetta Stone
About 5 min
Rosetta Stone
A tabulated list of Bashism's and their equivalent Murex syntax
Rosetta stone
Below is a reference table of common Bash code and how it could be written in Murex.
It is also recommended that you read the language tour if you want to learn more about shell scripting in Murex.
Output & error streams
Description | Bash | Murex |
---|---|---|
Write to stdout | echo "Hello Bash" | out "Hello Murex" echo "Hello Murex" [1] |
Write to stderr | echo "Hello Bash" >2 | err "Hello Murex" |
Write to file (truncate) | echo "Hello Bash" > hello.txt | echo "Hello Murex" |> hello.txt |
Write to file (append) | echo "Hello Bash" >> hello.txt | echo "Hello Murex" >> hello.txt |
Pipe commands | echo "Hello Bash" | grep Bash | echo "Hello Murex" | grep Murex out "Hello Murex" -> regexp m/Murex/ |
Redirect errors to stdout | curl murex.rocks 2>&1 | less | curl <!out> murex.rocks | less |
Redirect output to stderr | uname -a >&2 | uname <err> -a |
Ignore stderr output | echo something 2>/dev/null | echo <!null> something |
Output ANSI colors and styles | echo -e "\n\032[0m\033[1mComplete!\033[0m\n" | out "{GREEN}{BOLD}Complete!{RESET}" |
Quoting strings
Description | Bash | Murex |
---|---|---|
Infixing | echo "Hello $SHELL" | out "Hello $SHELL" |
String literals | echo 'Hello' $SHELL | out 'Hello' $SHELL |
Nesting quotes | echo 'Hello \'Bob\'' | out %(Hello 'Bob') |
Process management
Description | Bash | Murex |
---|---|---|
Exit number | $? | exitnum |
Background jobs | command & | bg { command } |
Job control | ps ,jobs ,bg pid ,fg pid | fid-list ,jobs ,bg fid ,fg fid |
Happy paths | command && command | command && command try {command; command} |
Unhappy paths | command || command | command || command try {command}; catch {command} |
Pipe fail | set -o pipefail | runmode trypipe module runmode trypipe function trypipe { commands } |
Comments
Description | Bash | Murex |
---|---|---|
Single line | # comment | # comment |
Multiple lines | :<<EOC line 1 line 2 EOC | /# line 1 line 2 #/ |
Mid-line | n/a | eg out foo/#comment#/bar |
File pattern matching
(also known as "wildcards")
Description | Bash | Murex |
---|---|---|
Globbing | eg ls *.txt | eg ls *.txt (in the interactive terminal) g pattern eg ls @{g *.txt} |
Regexp | n/a | rx pattern eg ls @{rx '*\\.txt'} |
File type matching | n/a | f flags eg f +s (only return symlinks) |
Chaining | n/a | eg f +f | g *.txt | !g murex.* (returns only files with the extension "txt" that aren't called "murex") |
Expressions
Description | Bash | Murex |
---|---|---|
Assignment | foobar = $((1 + 2 * 3)) | foobar = 1 + 2 * 3 [2] |
Comparison, string | [ "$(command parameters...)" == "value" ] | command(parameters...) == "value" [2] [7] ${command parameters...} == "value" [2] [5] |
Comparison, numeric | [ $integer -eq 5 ] | $number == 5 [2] |
Arithmetic | echo $(( 1+2*3 )) | 1 + 2 * 3 [2] out (1+2*3) [2] [5] |
Supported data types | 1. String, 2. Integer (all variables are strings) | 1. String, 2. Integer, 3. Float (default number type), 4. Boolean 5. Array, 6. Object, 7. Null (all variables can be treated as strings and/or their primitive) |
Variables
Description | Bash | Murex |
---|---|---|
Printing a variable | echo "$foobar" | out $foobar [5]$foobar (variables don't need to be quoted in Murex) |
Assign a local variable | local foo="bar" | $foo = "bar" [2] [6]out "bar" | set $foo |
Assign a global variable | foo="bar" | $GLOBAL.foo = "bar" [6]out "bar" | global $foo |
Assign an environmental variable | export foo="bar" | export foo = "bar" [1] [2] [3]$ENV.foo = "bar" [6]out "bar" | export $foo [3] |
Assign with a default value | FOOBAR="${VARIABLE:-default}" | $foobar = $variable ?? "default" |
Arrays
(eg arrays, lists)
Description | Bash | Murex |
---|---|---|
Creating an array | array_name=(value1 value2 value3) | %[value1 value2 value3] %[value1, value2, value3] eg array_name = %[1, 2, 3] , eg %[hello world] | foreach { ... } |
Accessing an array element | ${array_name[0]} | $array_name[0] (immutable) $array_name.0 (mutable) [5] array | [0] |
Printing multiple elements | echo ${array_name[1]} ${array_name[0]} | @array_name[1 0] array | [1 0] |
Printing a range of elements | n/a | @array_name[1..3] array | [1..3] |
Printing all elements | echo ${array_name[*]} | @array_name |
Iterating through an array | for item in array; do; Â Â Â Â $item done; | array | foreach item { $item } eg %[Tom Richard Sally] | foreach name { out "Hello $name" } |
Objects
(eg JSON objects, maps, hashes, dictionaries)
Description | Bash | Murex |
---|---|---|
Creating an object | n/a | %{ key: value, array: [1, 2, 3] } [2] eg object_name = %{ key: val, arr: [1,3,3] } eg %{ a:1, b:2, c:3 } | formap { ... } |
Accessing an element | n/a | $object_name[key] (immutable) $object_name.key [5] (mutable) object | [key] |
Printing multiple elements | n/a | $object_name[key1 key2] object | [key1 key2] |
Accessing a nested element | n/a | $object_name[[.path.to.element]] (immutable) [4]$object_name.path.to.element (mutable)object | [[.path.to.element]] [4] |
Iterating through an map | n/a | object | formap key value { $key; $value } eg %{Bob: {age: 10}, Richard: {age: 20}, Sally: {age: 30} } | formap name person { out "$name is $person[age] years old" } |
Sub-shells
Description | Bash | Murex |
---|---|---|
Sub-shell, string | "$(commands)" eg "echo $(echo "Hello world")" | ${commands} [5] eg out ${out Hello world} |
Sub-shell, arrays | $(commands) eg $(echo 1 2 3) | @{commands} [5] eg out @{ %[1,2,3] } |
In-lined functions | n/a | function(parameters...) [7] eg out uname(-a) |
Common one-liners
Description | Bash | Murex |
---|---|---|
Add $PATH entries | export PATH="$PATH:/usr/local/bin:$HOME/bin" | The same Bash code works in Murex too. However you can also take advantage of Murex treating $PATH as an array %[ @PATH /usr/local/bin "$HOME/bin" ] | format paths | export $PATH |
Iterate directories | for i in $(find . -maxdepth 1 -mindepth 1 -type d); do     echo $i done | f +d | foreach $dir {     out $i } |
If $dir exists... | if [ -d "$dir" ]; then     # exists fi | if { g $dir | f +d } then {     # exists } |
Print current directory | result=${PWD##*/}; result=${result:-/}; printf '%s' "${PWD##*/}" (read more) | $PWD[-1] |
Footnotes
- Supported for compatibility with traditional shells like Bash.
- Unlike Bash, whitespace (or the absence of) is optional.
- Environmental variables can only be stored as a string. This is a limitation of all major operating systems.
- Path separator can be any 1 byte wide character, eg
/
. The path separator is defined by the first character in a path. - Murex uses
${}
for sub-shells and$()
for variables, the reverse of what Bash and others use. The reason for this difference is because{}
always denotes a code block and()
denotes a sub-expression or string. So${foobar}
makes more sense as a sub-shell syntax executing a block, while$(foobar)
makes more sense as the syntax for a scalar. - When assigning a variable where the right hand side is an expression, eg
$foo = "bar"
, the dollar prefix is optional. Theset
,global
andexport
keywords are considered deprecated. - The
command(parameters...)
only works for commands who's names match the following regexp pattern:[._a-zA-Z0-9]+
. Which is exclusively uppercase and lowercase English letters, numbers, full stop, and underscore.
See Also
- Filter By Range
[ ..Range ]
: Outputs a ranged subset of data from stdin - Function / Module Defaults (
runmode
): Alter the scheduler's behaviour at higher scoping level - Get Nested Element (
[[ Element ]]
): Outputs an element from a nested structure - Named Pipes: A detailed breakdown of named pipes in Murex
- Pipe Fail (
trypipe
): Checks for non-zero exits of each function in a pipeline - Terminal Hotkeys: A list of all the terminal hotkeys and their uses
- Truncate File (
>
): Writes stdin to disk - overwriting contents if file already exists - Try Block (
try
): Handles non-zero exits inside a block of code &&
And Logical Operator: Continues next operation if previous operation passes>>
Append File: Writes stdin to disk - appending contents if file already exists>>
Append File: Writes stdin to disk - appending contents if file already exists@Array
Sigil: Expand values as an arraystring
(stringing): string (primitive)||
Or Logical Operator: Continues next operation only if previous operation fails- index: Outputs an element from an array, map or table
This document was generated from gen/user-guide/rosetta-stone_doc.yaml.