[Question]
  [
# I see your BIDMAS and raise you a BADMIS
## Challenge
Given a set of numbers with operators between them: "5 + 4 \* 9 / 3 - 8", return all the possible results of the expression for every permutation of the order of basic operations: [/, \*, +, -].
## Rules
* Standard loopholes forbidden
* I/O
	+ Input must be ordered with infix operations, but however that is easiest (string or array)
	+ You are not required to support unary operators (e.g. "-3 \* 8 / +2")
	+ Integers can be replaced by floats for languages that implicitly parse type (e.g. 45 ⟶ 45.0)
	+ Output must be all of the possible results of the expression, no specified format or order
* All of the inputs are valid (e.g. do not need to deal with "7 / 3 + \*"). This also means that you will never need to divide by zero.
* Operators are all left-associative so "20 / 4 / 2" = "(20 / 4) / 2"
* This is Code Golf so fewest number of bytes wins
## Test Cases (With explanation)
* "2 + 3 \* 4" = [14, 20]
	+ 2 + (3 \* 4) ⟶ 2 + (12) ⟶ 14
	+ (2 + 3) \* 4 ⟶ (5) \* 4 ⟶ 20
* "18 / 3 \* 2 - 1" = [11, 2, 6]
	+ ((18 / 3) \* 2) - 1 ⟶ ((6) \* 2) - 1 ⟶ (12) - 1 ⟶ 11
	+ (18 / 3) \* (2 - 1) ⟶ (6) \* (1) ⟶ 6
	+ (18 / (3 \* 2)) - 1 ⟶ (18 / (6)) - 1 ⟶ (3) - 1 ⟶ 2
	+ 18 / (3 \* (2 - 1)) ⟶ 18 / (3 \* (1)) ⟶ 6
	+ 18 / ((3 \* 2) - 1) ⟶ 18 / 5 ⟶ 3.6
## Test Cases (Without explanation)
* "45 / 8 + 19 / 45 \* 3" = [6.891666666666667, 18.141666666666666, 0.11111111111111113, 0.01234567901234568, 0.01234567901234568, 5.765740740740741]
* "2 + 6 \* 7 \* 2 + 6 / 4" = [112 196 23 87.5]
  
[Answer]
# [JavaScript (V8)](https://v8.dev/), ~~118~~ 112 bytes
Prints the results.
```
f=(s,x='',y=x,o='+-*/')=>[...o].map(v=>f(s.split(v).join(x+v+y),x+')',y+'(',o.replace(v,'')))|print(eval(y+s+x))
```
[Try it online!](https://tio.run/##TYzRioMwEEXf@xWDL5kxMaLtdl2W@COlD6EoWGwNJoTI7n67m9hS@jLcOXPnXLXX9jIPxhW@WddeoRVBMSYWFcSkGC/ykpFqT1LK6Sxv2qBXbY9WWjMODj3J6zTcMXDPFxKBM4q/nCETk5w7M@pLh14wRkS/Zh7uDjuvR1y45YFodZ11oMCCauEHHgVL39Bv87HH8LfbpSZmNXDYQw6HjJ6kaqDcUA0FVC98@Ii4ie3qK4a45bB/HZPlGMnn9pZy@WasUzfKjvGSpEmQ2smWrBvLaP0H "JavaScript (V8) – Try It Online")
Or [see the deduplicated results](https://tio.run/##TY7LbsMgEEX3@YpRNkAgRHk0TVsRqd/gZdsFsklF5BgLKMV9fLs7WFHUFcy5d47mrJMOtbd9XKbDOJ4UDSIrQsSgsnCK8OViRZg6vkgp3Zu86J4mdTzRIEPf2kgTk2dnO5p54gMTmROGu5xQIpz0pm91bWgShDDGfnpvu0hN0i0deOCZsTGaEEFBAHWE7xlAhUNnPqEy8QnHaQNRLnklddPQzEqAF0xv7brgWiNb904rGeyXAQ4EGhui7eoI3oSPNobH145g8Oy9HuTJuwutrocTAYSVHWyg8Xc2KyfR@QbZFhawm7MrWR9gNaENLGF9w7s7xAdsrx/wg9MCtrewWPZI7qe18l/9M25KF2V7TIq0CEq72Ip1YnM2/gE).
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 285 bytes
```
x=>{int c=0,j,t=1,i;for(;c++<25;t=c){var r="*+-/".ToList();for(i=j=1;j++<4;t=t/j+1)(r[j-1],r[t%j])=(r[t%j],r[j-1]);float k(float z,int p=4){char d;int l;float m;return i<x.Count&&(l=r.IndexOf(d=x[i][0]))<p?k((m=k(x[(i+=2)-1],l))*0+d<43?z*m:d<44?z+m:d<46?z-m:z/m,p):z;}Print(k(x[0]));}}
```
[Try it online!](https://tio.run/##lVZtT@M4EP5MfsUI6bZJm7a0dLk92oDQ3n1AQjq0i7QfKj64iUvdOnFkO1Ba9bdzM05fUra8XATCGY@fmXlmHofYNGMjXq5iK1Q2uBHGDpLnjKUivrgYRy/z6GIpMgtxdBJOQxt1QtEfK@3340Zj0P3at1EcLB@ZBh0d1xvN9nHrThGIHzg3EU2jTn@Kvj10te1poxP4ejhtdu5DPbR/TO@DyC8XYWnGc1IxCzO//LsIKXwe9YJlPME4SZ/e5dor7WtuC52BGMxb31WR2S9ffBnp1nWW8Pm/Yz@J5kNxPzy5D4JBfjnz/TSa@fOhLxpRN6AsZBDUTxrJoHd6uain57joXS4abnF2uWim54t2GubB@aK/utUY2qfjBNdfrV76nveoRAKWY8XG4v4DiCwvbABL74hokcgFRJDxJ9jjFvnxjpAhzuKJT44MD5ZnWz9zKZBAh3EkxlAy0brTz7dMG@6zEFRhoWRgtPY7okitqyTxRwR9tMJfLg2HrZ2RHc2/tLD8RmTcL1PtA2bik5tb7rbpdeV5rrjjLjTgFOrQO0aY0tT5Bm1n60ITOjt77yvav6F/5y9c4FsdTne7BHSGpj/dQVq3q6Bd8ka8M9wiXIIgd8IjXGdD9xfAh6YTPv202zcsHSUMLJuVnULW97rilY6vB/590CsYFVk8ATWGhMuYaUZSMjBlacpxNtQDtxOucQGGPXIYPWOl60i/Sen99JXKodsDK1JuwGcpDTzFzblOC7uOy8BwZ5U8e7AT6EHMMphg6MDbYK0V227UmxXFHo56nQkrmBQLDjimphxphFcYlVmlzRb1LcUfxv2Ow285IDdwh2lWagiJKOqQ5qaQlhqlQ2DSKLJgcYLI7Hg7tI/ulF2Kb1wusPw9wb/5GGUAUsVMwhh7TLlBbVYL4UlgxgtiIy605gjyyGTBgcVxkTKJdSXAsgTyqkuuecwTnsW8kvnBS@0gXz9VymHCJRJF/RNsJLmpIL2@Cd@eo@sxsi4M4E@mrOuAZNjUrEhHXHtV53ev0wokwBWWS0ibajfjUTOVwinkRDw4OUxwKqsHDtIz8z@rbYAfHKGMQIlhw2TZIwqwbQptrftk9qo89FU4HIPqVE7O@o1oGZ9vmERBSKmeaJIPMUOzYThOissp9OB/P5uMkl3kw7RjJPKoWMqYbkgNupMOmVPaZrSgltb2Uvr4M7mfUqI2hbM81ypHWJR7mR8JCSWcuvj7EvJri1qwFzgPPsvFLTNmfbN/MFn4Pf80x//QZ3RaoEDWEqtiv9LMart69d/CuxGcr4Nd33h4vdJUUS2z3WiNhd6q1A2PZdqSj2POq2aw@g8 "C# (Visual C# Interactive Compiler) – Try It Online")
```
x=>{                                          //Lambda taking in a List<dynamic>
  int c=0,j,t=1,i;                            //A bunch of delcarations jammed together to save bytes
  for(;c++<25;t=c){                           //Loop 24 times (amount of permutations a set of length 4 can have)
    var r="/+*-".ToList();                    //Initialize r as list of operators
    for(i=j=1;j++<4;t=t/j+1)                    //Create the Tth permutation, saving result in r, also reset i to 1
      (r[j-1],r[t%j])=(r[t%j],r[j-1]);
    float k(float z,int p=4) {                //Define local function 'k', with z as current value accumalated and p as current precedence
      char d;int l;float m;                   //Some helper variables
      return i<x.Count                        //If this is not the last number
        &&(l=r.IndexOf(d=x[i][0]))<p?         //  And the current operator's precedence is higher than the current precedence
      k(                                      //  Recursive call with the accumalative value as
        (m=k(x[(i+=2)-1],l))                  //    Another recursive call with the next number following the current operator as seed value,
                                              //    And the next operator's precedence as the precedence value, and store that in variable 'm'
        *0+d<43?z*m:d<44?z+m:d<46?z-m:z/m,    //    And doing the appropriate operation to m and current value ('z')
        p)                                    //  Passing in the current precedence
    :z;                                       //Else just return the current number
    }
    Print(k(x[0]));                           //Print the result of calling k with the first number as starting value
  }
}
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 132 bytes
```
a=>(w=[],F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):w.push(a))("+-*/",a)&&w
```
[Try it online!](https://tio.run/##bY3LboMwEEX3/YqRVUUzYGwR0uYhme7yE4CUgThpIhIgtGFR9dupHaldVOzmzrm658x37qvbqf2Irs3ejgczsklxMFkhtwZLyWTS8i1TSpWFunCLnUm3WKqbbWuuLHZSCJL8l@2da9zpLM/3KipChDx//uq@4fdBoT7uSPoaEW0G1X7278hEKMIo0MIJZ7NhrJpr39RW1c0RDyjmEEICASwE0dM/Fq9AP@AcIognCosXV1i5hXjtDpcCSCZq3vHq2PIx5W896fOaxHHPxh8 "JavaScript (Node.js) – Try It Online")
This allows duplicated outputs.
# [JavaScript (Node.js)](https://nodejs.org), ~~165~~ ~~161~~ ~~155~~ ~~153~~ ~~152~~ 137 bytes
```
a=>Object.keys((F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):F[a]=1)("+-*/",a)&&F)
```
[Try it online!](https://tio.run/##bY3dasJAEIXv@xTDUmQmP7vEaGsLG@9y2wdIAs7GVarRJEYEKX32dFdoL0ru5sx3ON@BbzzUl8/uGp/brR13emSdfZiDra/yaO8DYq7RREw6M@tCSmkqeeIOe53laOTFdg3XFvtICIr4L9sbN7hRRVluZVyFCGX5/NV/w@@DQrXfUORrRPSeF1zphFCEcaCEs81mOY11ex7axsqm3eMOxRxCSCGAhSB6@seSFagHnEMMyURhsXSFlVtI3tzhUgDpRM07Xhx7fUz5W036vCZ13LPxBw "JavaScript (Node.js) – Try It Online")
Takes a string with spaces between operators and numbers.
```
a=>                                             // Main function:
 Object.keys(                                   //  Return the keys of the -
  (
   F=(                                          //   Index container (helper function):
    b,                                          //    Operators
    a                                           //    The expression
   )=>
    b                                           //    If there are operators left:
    ?[...b].map(                                //     For each operator:
     q=>
      F(                                        //      Recur the helper function - 
       b.replace(q,""),                         //       With the operator deleted
       a.replace(                               //       And all -
        eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`), //        Expressions using the operator
        eval                                    //        Replaced with the evaluated result
       )
      )
    )
    :F[a]=1                                     //     Otherwise - set the result flag.
  )(
   "+-*/",                                      //    Starting with the four operators
   a                                            //    And the expression
  )
  &&F
 )
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~92 90~~ 88 bytes
```
{map {[o](@_)($_)},<* / + ->>>.&{$^a;&{S:g{[\-?<[\d.]>+]+%"$a "}=$/.EVAL}}.permutations}
```
[Try it online!](https://tio.run/##JY3NCoJAAITvPsUQJrmbu2hqVmZ16NYt6KImC2kI/qF1iGWf3ZIuw/AxH9PlfeWP9QdGgT1GWYsOMm7TxTEzF3pmqmVIwEFhRVHEDKnfxc6Q1@1Txol1COPkwdKIpnQ@0wVmaq9zdr6dLkqxLu/r90u8yrYZ1DiID9jvo2h7VGWTD6NtwaFYaVMQuJod8Kk4FmzN9TgCCnvD4XrkP/IJ1mRS/B/8Ag "Perl 6 – Try It Online")
Takes a string with a space after any operators and returns a set of numbers. This mostly works by substituting all instances of `n op n` with the eval'ed result for all permutations of the operators.
### Explanation:
```
{                                                                                   }  # Anonymous code block
                    <* / + ->>>.&{                                    } # Map the operators to:
                                  $^a;&{                             }  # Functions that:
                                        S:g{                }      # Substitute all matches of:
                                            \-?<[\d.]>+]+        # Numbers
                                                         %$a     # Joined by the operator
                                                              =$/.EVAL   # With the match EVAL'd
 map {           },                                                    .permutations   # Map each of the permutations of these operators
      [o](@_)        # Join the functions
             ($_)    # And apply it to the input
```
[Answer]
# [Python 3](https://docs.python.org/3/), 108 bytes
```
f=lambda e,s={*"+-*/"}:[str(eval(p.join(g)))for p in s for g in zip(*map(f,e.split(p),[s-{p}]*len(e)))]or[e]
```
[Try it online!](https://tio.run/##RVBNb@MgEL37V4x8ApeQ4O9E8qFa9bCn/QGutaIJbl05gAzZtmvlt2cHUmkRh8fMe2@GZ7/8m9HF7TZ2szy/nCQo5ro1Sx822Ta9HnrnF6L@yJlY/m4mTV4ppaNZwMKkwUGArwH@nSzJztKSkSnu7Dx5Yinr3Wa11yGblSYKlYNZejXcvHL@91E65aCDPiFpDg9QQAZlyqAXJYN8N1CGDdHCNnZy2IAI3ZxBwWsGeIW4k8oKSS1aiD0CfGVQBOqO70RelFXd7AWDHRffBy0q3tRVU2K55u1e1HUdsGi5KOPjbhzWqtGtiQsEvL2vmBcM2oZXYQd0E/t6oMmQJNPZmsWDvpztF0gH2iZJiMhYx0B9xtD@f/6QAB5z8ZiCQ506kZjgbKRnTnkyEhRibDQSpXMKzUOWqKHQdRGjLQWpTziMy3k@zsapQIgDKYMxfdY/tb34QzBZ0fH6rH9d/HdlRSoWnj6tOuIGB1hRhoU0zrTLpD1Jf5hlwTY8avehlpTe/gE "Python 3 – Try It Online")
The function takes a single string as input and returns a list of possible results.
# Ungolfed
```
def get_all_eval_results(expr, operators={*"+-*/"}):
    results = []
    for operator in operators:
        remaining_operators = operators - {operator}
        # Split expression with the current operator and recursively evaluate each subexpression with remaining operators
        sub_expr_results = (get_all_eval_results(sub_expr, remaining_operators) for sub_expr in expr.split(operator))
        for result_group in zip(*sub_expr_results):   # Iterate over each group of subexpression evaluation outcomes
            expr_to_eval = operator.join(result_group)  # Join subexpression outcomes with current operator
            results.append(str(eval(expr_to_eval)))   # Evaluate and append outcome to result list of expr
    return results or [expr]  # If results is empty (no operators), return [expr]
```
[Try it online!](https://tio.run/##bVRNb9swDL37VxDeRUpdN86HkxTIYRh66C477JgGhucojQdHEiS5bRb0t2ek/NUGNQpUpt575CPp6JM7KDm9XHZiD8/CZXlVZeIlrzIjbF05y8SbNhEoLUzulLHr8yi8uR3dhe/8PgB8WhysYbP1gb0yPRxKOVAbfMM55qUs5XPWXyJ/ON/CuXt5D3rWN/itq9IBVSSsLZWE19IdwB0EFLUxQrohcS53mAbDtnwR1QnIU507ASIvDmDrP9cqfU1DHX1mhGeEzwaz7MtmdcDoK4vct6aDUGvof2zJFOtQnA@GCd4oZ89G1Zoo/0rNRtf18HvfnkdHGgLUizCNz4am9leG22bQUdWuUEcxeKXHazvlvX0YTPxXlZJ9rIhT2p8YvUrQqTatvR7Op1ythTjXWsgds84wSss@1sA59wYfuiHSdBtClwqcaqWgKq0jz6TQrqirjew3Fbu6obut79m@j5cWxFG7EzCphiXgUcdvSBcnrMuK3Aq/8wELJ3ADUxjBLIxgk8wimIy3PMKLZAl3/maCG53Q7SSCaZxGgH9J0oBmcwQtUSJZ4QHfRjAl6DgeJ5PpbJ4uVkkE4zhpH5SYx4t0vphhOI2XqyRNUzonyziZ@ZdGmMpKUW3hC6DzXVPiZBrBchHPqQZUS1bplgfbICiPWhkHsj7qE@QWpA6C5mO2ETWT1m8w33zN2H3sgkWe2LFjrtm@UrmLrHBffyCohcPknptbKzBfJSRDGQ7rtT9jJu4HLHWM/KJSVhDA14DT2IdP8lHq2tHS0w@FfX@Sv2rXRs4IxcDDmxYFFnUPZ6RhIPQ5tSmlY@EPhRtZOPgu7aswIb/8Bw "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 30 bytes
```
œṡ⁹¹jṪḢƭ€jŒVɗßʋFL’$?
Ḋm2QŒ!çƒ€
```
[Try it online!](https://tio.run/##y0rNyan8///o5Ic7Fz5q3HloZ9bDnase7lh0bO2jpjVZRyeFnZx@eP6pbjefRw0zVey5Hu7oyjUKPDpJ8fDyY5OAKv5bP2qYo6Brp/CoYa714fajkx7unKHC5Xa4XQUoGfn/fzRXtKGOkraSjpGOkpaSjnGsDle0iamOkr6SjgVY3NASzAGJweSNwBJmYAFzMAkXAamM5YoFAA "Jelly – Try It Online")
A pair of links. The second one is the main link, and takes as its argument a Jelly list of floats/integers interspersed with the operators as characters. This is a flattened version of the way Jelly takes its input when run as a full program with command line arguments. The return value of the link is a list of list of single member lists, each of which is a possible value for the expression.
## Explanation
### Helper link
Takes a list of floats/integers alternating with operators (as characters) as its left argument and an operator as a character as its right argument; returns the input list after evaluating numbers separated by the relevant operator, working left to right. 
```
œṡ⁹                  | Split once by the right argument (the operator currently being processed)
                   ? | If:
                  $  | - Following as a monad
                L    |   - Length
                 ’   |   - Decremented by 1
              ʋ      | Then, following as a dyad:
   ¹                 | - Identity function (used because of Jelly’s ordering of dyadic links at the start of a dyadic chain)
    j       ɗ        | - Join with the following as a dyad, using the original left and right arguments for this chain:
     ṪḢƭ€            |   - Tail of first item (popping from list) and head from second item (again popping from list); extracts the numbers that were either side of the operator, while removing them from the split list
         j           |   - Joined with the operator
          ŒV         |   - Evaluate as Python (rather than V because of Jelly’s handling of decimals with a leading zero)
            ß        | - Recursive call to this helper link (in case there are further of the same operator)
               F     | Else: Flatten
```
### Main link
Takes a list of floats/integers alternating with operators (as characters)
```
Ḋ         | Remove first item (which will be a number)
 m2       | Every 2nd item, starting with the first (i.e. the operators)
   Q      | Uniquify
    Œ!    | Permutations
      çƒ€ | For each permuted list of operators, reduce using the helper link and with the input list as the starting point
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~182~~ 172 bytes
```
import re
def f(s,P=set('+-/*')):
 S=[eval(s)]
 for p in P:
	t=s
	while p+' 'in t:t=re.sub(r'[-\d.]+ \%s [-\d.]+'%p,lambda m:`eval(m.group())`,t,1)
	S+=f(t,P-{p})
 return S
```
[Try it online!](https://tio.run/##XVDBasMwDD3XXyE6iu3ESUm2QhfIdedCj2mgKXXWjCQ2trKyjX17J3eFlZ0k6z09vyf7gScz5pdLN1jjEJxmR91CK7zalF6j4HGyjLiUBYNtWen3phde1gxa48BCN8KmYDMsPZudT12vwcYcOI2xwNLp1E8H4XiV7I5pHcNu4eHW84VVfTMcjg0Mxf6qO6SvzkxWSLlXqDLJZtu4bAWqTfJlvyUjczi5EbaXYPGFfJAphBJ86m3foSAK6XiaDI0VHp0Kte1NgwqroshrSRRjAwOrLAx@Bchy@ma6UfhpEJ@dFUFGETGuOK@lIktVkWQ1bT9QZvQhuIfGaRjNOTzwpOH6UTjMQKXxgIF980wx/gKEu4aBZMw6kqMs8xwSeIQY1lRXoZ/LezCiYQz5fyBbw5LWoiuS3SNPK0LWtJM9U0OvKGxe2A8 "Python 2 – Try It Online")
Takes input with ints formatted as floats, as per "Integers can be replaced by floats for languages that implicitly parse type".
[Answer]
# [Julia 1.2](http://julialang.org/), 88 (82) bytes
```
f(t)=get(t,(),[f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2)...;])
```
```
julia> f([2, +, 3, *, 4])
2-element Array{Int64,1}:
 20
 14
julia> f([18, /, 3, *, 2, -, 1])
6-element Array{Float64,1}:
 11.0
  6.0
  2.0
  3.6
  6.0
  6.0
```
Takes a tape in the form of a vector of numbers and infix functions, evaluates each single function call and recursively passes each resulting tape back to itself until only a single number is left. Unfortunately, `get(t, (), ...)` doesn't work properly in Julia 1.0, so a newer version is needed.
Six bytes can be saved, if a bunch of nested arrays is acceptable as an output:
```
f(t)=get(t,(),f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2))
```
Output:
```
julia> f([18, /, 3, *, 2, -, 1])
3-element Array{Array{Array{Float64,1},1},1}:
 [[11.0], [6.0]]
 [[2.0], [3.6]] 
 [[6.0], [6.0]] 
```
[Answer]
# Perl 5 (`-alp`), 89 bytes
```
my$x;map{$x.=$`.(eval$&.$1).$2.$"while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=$x;/[-+*\/]/&&redo
```
[TIO](https://tio.run/##K0gtyjH9/z@3UqXCOjexoFqlQs9WJUFPI7UsMUdFTU/FUFNPxUhPRak8IzMnVT8mRTtaV1srRj9Ww95WA8jT1NDT0tTUT691cLNWibcFGqIPVaCvplaUmpL//7@RtrGWCZehhb6xlpGu4b/8gpLM/Lzi/7qJOQX/dX1N9QwMAQ)
or unique values, 99 bytes
```
my%H;map{$H{$`.(eval$&.$1).$2}++while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=join$",keys%H;/[-+*\/]/&&redo
```
]