Rosetta Stone

A tabulated list of Bashism’s and their equivalent Murex syntax

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.

Table of Contents

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

  1. Supported for compatibility with traditional shells like Bash.
  2. Unlike Bash, whitespace (or the absence of) is optional.
  3. Environmental variables can only be stored as a string. This is a limitation of current operating systems.
  4. Path separator can be any 1 byte wide character, eg /. The path separator is defined by the first character in a path.
  5. Murex uses ${} for subshells 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 strings. So ${foobar} makes more sense as a subshell executing the command foobar, while $(foobar) makes more sense as the variable $foobar.
  6. When assigning a variable where the right hand side is an expression, eg $foo = "bar", the dollar prefix is optional. The set, global and export keywords are considered deprecated.
  7. 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, fullstop / period, and underscore.

See Also


This document was generated from gen/user-guide/rosetta-stone_doc.yaml.

This site's content is rebuilt automatically from murex's source code after each merge to the master branch. Downloadable murex binaries are also built with the website.

Last built on Wed May 29 22:34:12 UTC 2024 against commit 59427ac59427acc045d10935b148c16c2c3860e1470e756.

Current version is 6.0.1000 which has been verified against tests cases.