String Manipulation Interpreter Summary

A new string manipulation language has been made, using only the characters $+#-!*|@&gt;! Your task is to implement an interpreter for it in as few bytes as possible.

Input

A string, which is a single line of this language. This can be taken in any reasonable way (stdin, function parameter, command line argument etc.), or as a predefined variable. If the program asks for user input, accept all user input it asks for from stdin and nothing more, see below. You may assume it is a valid program.

Output

Whatever the language would output, specifications below. You must output a string, in any reasonable way (stdout, function output, etc.), or a variable value. When the language outputs explicitly, this must go to stdout. Standard loopholes are banned.

Language Specifications

Processing and Syntax

The language has a very simple form of processing as it does only string manipulation: it starts with an empty string (""), and changes it with each term. A term is made up of one or two parts: a function (below) followed by possibly a parameter(below), which edits its behaviour. Terms are separated by pipes (|). You may assume it will not be an empty program, and no term will be empty. You should output the value at the end of the program.

Functions

The language has just 6 functions, as shown below. Each function either accepts one or zero parameters.


+ concatenate strings (takes one string parameter, concatenates it to the current value)
! reverse the character order of the current value (no parameter)
* repeat the string (takes one integer parameter, repeats the current value that many times)
- removes all occurrences of a value (takes one string parameter, removes all occurrences of it from the current value)
$ [pseudo-]randomly shuffles the current value (no parameter)
&lt; output the current value to stdout (no parameters)


Values

These are the values that may be passed to functions, represented by regex that would match them:


@[^|]* a string literal, including any character other than pipes. It may be empty.
#[0-9]+ an integer literal
&gt; the next line of stdin. If used with *, convert to integer.


Test Cases

╔════════════════════════╤═════════════╤══════════════╗
║code                    │input        │output        ║
╟────────────────────────┼─────────────┼──────────────╢
║+&gt;|!|+@hello|*&gt;         │13           │31hello31hello║
║                        │2            │              ║
╟────────────────────────┼─────────────┼──────────────╢
║+&gt;|+@abcdefg|$          │hello        │hcloeebafdlg  ║
╟────────────────────────┼─────────────┼──────────────╢
║+@how areyou|-@o|-&gt;     │w            │h areyu       ║
╟────────────────────────┼─────────────┼──────────────╢
║+@out|&lt;|*#3             │             │out           ║
║                        │             │outoutout     ║
╟────────────────────────┼─────────────┼──────────────╢
║+&gt;                      │what ever 345│what ever 345 ║
╟────────────────────────┼─────────────┼──────────────╢
║+@$pe&lt;i@l|&lt;|-@$pe&lt;i@l|+&gt;│A|$o $pe&lt;!@| │$pe&lt;i@l       ║
║                        │             │A|$o $pe&lt;!@|  ║
╟────────────────────────┼─────────────┼──────────────╢
║&lt;|+&gt;|!|&lt;                │input text   |              ║
║                        │             │txet tupni    ║ 
║                        │             │txet tupni    ║
╟────────────────────────┼─────────────┼──────────────╢
║+@&gt;#                    │             |&gt;#            ║
╚════════════════════════╧═════════════╧══════════════╝


Note that test case 2 is random, so any permutation of the characters in it is valid. Also, the outputs in the table are seperated by newlines, but your program doesn't have to do the same. The last value in each case the the final output.

Example (Un-golfed) python interpreter

Try it online! IMO better if you run it through IDLE or whatever you use. (I golfed it down to 424 bytes after, but I'm sure you lot can do better).
R, 287 286 273 269 bytes



function(C,x='',`[`=gsub,`!`=intToUtf8,`?`=utf8ToInt){for(k in el(strsplit(C,'\\|'))){B=eval(parse(t='^.'['','(?&lt;=.)&gt;$'['readLines(,1)','[@#](.+)'['"\\1"',k],,T]]));x=switch((?substr(k,1,1))%%13-2,strrep(x,B),paste0(x,B),,B['',x,f=T],!rev(?x),print(x),,!sample(?x))};x}


Try it online!


-1 thanks to @Kirill L.
-4 thanks to @Giuseppe


Unrolled code and explanation :

function(C){                                      # C is the string manipulation expression
  x = ''                                          # initialize x = ''
  tokens = el(strsplit(C,'\\|'))                  # split C by pipe '|'
  for(k in tokens){                               # for each token k
    arg2 = k
    arg2 = gsub('[@#](.+)','"\\1"',k)             # replace @X or #X with "X" (in quotes)
    arg2 = gsub('(?&lt;=.)&gt;$','"readLines(,1)"',
                 arg2,perl=T)                     # replace &gt; with readLines(,1)
    arg2 = gsub('^.','',arg2)                     # remove the first character
    B = eval(parse(t=arg2))                       # evaluate the string : this will be our 
                                                  # second argument B
    A = substr(k,1,1)                             # take the first character : 
                                                  # i.e. the main command (+,-,! etc)
    x = switch(A,                                 # switch on the main command, execute the 
            '+'=paste0(x,B),                      # corresponding expression and 
            '!'=intToUtf8(rev(utf8ToInt(x))),     # store the result into x
            '*'=strrep(x,B),                      # Note: in the actual code we switch on
            '-'=B['',x,f=T],                      # the utf8 value MOD 13-2 of the command
            '$'=intToUtf8(sample(utf8ToInt(x))),
            '&lt;'=print(x)
        )
    }
    x                                             # return x (and print it implicitly)
}