Does the fishy road have an end? I love >&lt;>, >&lt;> is life! 2D langages are amazing!
In this challenge, you will have to say if a "fishy" road has an end,
while code-golfing.

Definition

A fishy road is constructed with tiles, including the following ones:

v (go down)
&gt; (go right)
^ (go up)
&lt; (go left)
/ (mirror)
\ (mirror)


Any other character (except -|+) may be considered as a distraction, like some flowers (or fish heads) on the border of the road.

A road always start on the upper-left corner of a rectangular grid, delimited by -|+symbols. The road has an end if, by following it, you end up on a border, else, you'll be trapped in an infinite path.

Finding your way on the road is accomplished by following directions given by v&gt;^&lt;and mirrors. A mirror will reflect by 90° depending on where you came from. Here's how it works (using v&gt;^&lt;to show directions):

 ^    ^
&gt;/&lt;  &gt;\&lt;
 v    v
&lt;/&gt;  &lt;\&gt;
 ^    ^


A road might be looking like this if it ends:

+--------------------+
|&gt;\/  this way &gt;\/&gt;  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         &gt;v     |
| /\/         ^&lt;     |
+--------------------+


An infinite loop :

+--------+
|&gt;&gt;\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+


Specifics

A road doesn't necessarily consist only of instructions. Spaces or letters can be used to complete it. This means you have to continue moving in the same direction except if you cross a character in &lt;v^&gt;-|.

There will always be one of v&gt;^&lt; in the upper-left corner, &lt; or ^ implies this road ends.

You may submit a function taking a string as parameter, or a standalone program using STDIN/whatever is the closest alternative in your language.

Your submission must return or print on STDOUT truthy/falsy values when it's done. Truthy values meaning the road has an end, while falsy means it is an infinite loop.

Test cases

+--------------------+
|&gt;\/  this way &gt;\/&gt;  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         &gt;v     |
| /\/ &gt;&lt;&gt;     ^&lt;     |
+--------------------+
    True

+--------+
|&gt;&gt;\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+
    False

+--+
|&lt;v|
|^&lt;|
+--+
    True

+--+
|&gt;v|
|^&lt;|
+--+
    False

+----------+
|v Hello \ |
|\\/\/   / |
| \/\\   \ |
|/  // &gt;\  |
|  ^/\&gt;\\/ |
|\  /\/\/  |
+----------+
    False

+-----+
|&gt;\/\\|
|//\\/|
|\/\\\|
|//\//|
|\/\/ |
+-----+
    True

2 test cases added as suggested by @MartinBüttner
+----+
|v   |
|\\  |
|//\ |
|\\v |
| \/ |
+----+
    False

+----+
|v   |
|\\  |
|//\ |
|\\^ |
| \/ |
+----+
    False

Test case inspired by @ETHproductions
+-------------------------+
|&gt;&lt;&gt;                      |
|something smells fishy...|
+-------------------------+
    False


Standard loopholes are forbidden (as always).

The winner will be the one with the shortest code in bytes.
(it would be amazing to see a >&lt;> answer :))
Non-compliant >&lt;> answer

You wanted >&lt;>, I give you >&lt;> !

I believe the only sane way to do this in >&lt;> is by copying the input in the codespace and letting the interpreter decide by itself if the input leads somewhere. Since >&lt;> doesn't implement threading anymore, that leaves us with a big problem : if the input has a loop, we'll get stuck into it.

These considerations taken into account, I decided to make a solution compatible with >&lt;> online interpreter so that it would be possible to assert if the interpreter is stuck in the input or just taking ages to do everything. I also had to add trailing lines to the code so the online interpreter shows the added code and doesn't crash when trying to write to it.

Oh and since I'm clearly disqualified by now, I didn't bother with golfing the code.

Without further ado, the code in all its glory :

50i:0(?v   :"^"=?v:"v"=?v:"&gt;"=?v:"&lt;"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
&gt;.!603f&lt;         v"."~                                     &lt;      &lt;   &gt;~1+010.
&gt;.!01+1p}:$}:}v! &lt;      &lt;      &lt;      &lt;      &lt;      &lt;
  ;oooo"true" &lt;&lt;
              ^


To use it, copy it in the online interpreter, add enough trailing lines to handle your input, submit the code, give it the input as ;-separated lines and enjoy the ride.

A few tests :


  With

+--------------------+
|&gt;\/  this way &gt;\/&gt;  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         &gt;v     |
| /\/         ^&lt;     |
+--------------------+` 

  
  Final codespace :

50i:0(?v   :"^"=?v:"v"=?v:"&gt;"=?v:"&lt;"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
&gt;.!603f&lt;         v"."~                                     &lt;      &lt;   &gt;~1+010.
&gt;.!01+1p}:$}:}v! &lt;      &lt;      &lt;      &lt;      &lt;      &lt;
  ;oooo"true" &lt;&lt;
            ^
 ....................
.&gt;\/           &gt;\/&gt;  .                   
. v^            \/   .
. v^   ^ ^           .
. \/\         &gt;v     .
. /\/         ^&lt;     .
 ....................

  
  Outputs "true" and stops.





  With

+--------+
|&gt;&gt;\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

  
  Final codespace :

50i:0(?v   :"^"=?v:"v"=?v:"&gt;"=?v:"&lt;"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
&gt;.!603f&lt;         v"."~                                     &lt;      &lt;   &gt;~1+010.
&gt;.!01+1p}:$}:}v! &lt;      &lt;      &lt;      &lt;      &lt;      &lt;
  ;oooo"true" &lt;&lt;
            ^
 ........ 
.&gt;&gt;\     .
.\\      .
.  \\    .
. \ /    .
 ........

  
  Loops forever.