Implement Ash's float division Ash has a bit of an interesting float division algorithm. It's designed to never return NaN, and things like signed zero and infinity need to be handled.
How it works:
Assume the inputs are positive for the rules below. One input being negative will always result in the output being negative, and both being negative will result in a positive output.

Zero divided by anything is 0
Anything other than 0 divided by 0 is Infinity
Anything other than Infinity divided by Infinity is 0
Infinity divided by anything other than Infinity is Infinity
Infinity divided by Infinity is 1
All other division works as normal

I/O:
For languages with floats that support signed zero and positive/negative infinity, floats are an accepted I/O format. For others, using a string is allowed. You can use any reasonable format in this string, and you can represent the infinities with anything that can't be confused with another number (such as I, ∞, inf, or :().
Input will always be two floats in your chosen representation, and output will be a single one. Floating point errors and large numbers being represented as Infinity are allowed.
Test cases:
0 / 0                   0
0 / 1                   0
0 / 8                   0
0 / Infinity            0
0 / -0                 -0
0 / -1                 -0
0 / -8                 -0
0 / -Infinity          -0
-0 / 0                 -0
-0 / 1                 -0
-0 / 8                 -0
-0 / Infinity          -0
-0 / -0                 0
-0 / -1                 0
-0 / -8                 0
-0 / -Infinity          0
1 / 0                   Infinity
8 / 0                   Infinity
Infinity / 0            Infinity
1 / -0                 -Infinity
8 / -0                 -Infinity
Infinity / -8          -Infinity
-1 / 0                 -Infinity
-8 / 0                 -Infinity
-Infinity / 0          -Infinity
-1 / -0                 Infinity
-8 / -0                 Infinity
-Infinity / -0          Infinity
Infinity / 1            Infinity
Infinity / 8            Infinity
Infinity / -1          -Infinity
Infinity / -8          -Infinity
-Infinity / 1          -Infinity
-Infinity / 8          -Infinity
-Infinity / -1          Infinity
-Infinity / -8          Infinity
Infinity / Infinity     1
Infinity / -Infinity   -1
-Infinity / Infinity   -1
-Infinity / -Infinity   1
1 / 1                   1
1 / 8                   0.125
1 / Infinity            0
1 / -1                 -1
1 / -8                 -0.125
1 / -Infinity          -0
-1 / 1                 -1
-1 / 8                 -0.125
-1 / Infinity          -0
-1 / -1                 1
-1 / -8                 0.125
-1 / -Infinity          0
8 / 1                   8
8 / 8                   1
8 / Infinity            0
8 / -1                 -8
8 / -8                 -1
8 / -Infinity          -0
-8 / 1                 -8
-8 / 8                 -1
-8 / Infinity          -0
-8 / -1                 8
-8 / -8                 1
-8 / -Infinity          0
1 / 0.125               8
0.1 / 0.2               0.5
10 / -3                 -3.333333
1 / 0.0000000000000001  10000000000000000

Other:
This is code-golf, so shortest answer in bytes (per language) wins!
Haskell, 35 bytes

x?y|isNaN$x/y=tanh x*tanh y|0&lt;1=x/y

Try it online!
The relevant function is (?), which takes two Doubles as input and returns a Double as output.
How?
The hyperbolic tangent is an amazing function (two bytes shorter than signum!).




x
tanh x




0.0
0.0


-0.0
-0.0


Infinity
1.0


-Infinity
-1.0



Haskell, 30 29 bytes
x?y|x/y&lt;=1/0=x/y|0&lt;1=tanh$x*y

Try it online!
Using MarcMush's amazing trick, which relies on the well-known formula1
$$
\tanh(x\cdot y)=\tanh(x)\cdot\tanh(y).
$$

1 I know, I know, maths.