text:
What will you bring for Thanksgiving?
Thanksgiving in the United States is coming up on November 24th. Many people will have a large dinner with their families, traditionally including turkey and many side dishes. This typically means the family members must coordinate who's going to bring each of the various dishes. In this challenge, the goal is to write a polyglot that outputs a different dish in each language it's run in.
Menu
(Selected from Wikipedia. In case it's not obvious, each line is one item.)
turkey
stuffing
dressing
cranberry sauce
mashed potatoes
gravy
winter squash
sweet potatoes
corn
green beans
green bean casserole
mac and cheese
macaroni and cheese
salad
rolls
biscuits
corn bread
pumpkin pie
apple pie
mincemeat pie
sweet potato pie
pecan pie
apple cider
sweet tea

Rules

Each submission must run in at least 3 languages, each of which must output a different item from the menu. You may not use multiple versions of the same language (e.g. Python 2 and Python 3 cannot be used in the same answer).
Each entry must have the same bytes in each language's encoding. For example, ɱ is byte 0x1D in Jelly's encoding, which corresponds to ¢ in 05AB1E's encoding.
Different languages may use different output methods, but entries must be full programs in all languages, and follow one of our default allowed IO methods.
No programs may take input, but any of the programs may print to STDERR or throw runtime/compile time errors and warnings as long as the correct output is still printed to STDOUT or a file.
Case and whitespace do not matter. For example, an output of GreenbeAN      S would still count as green beans.
As the central dish of every1 American Thanksgiving meal is turkey, one language must output turkey (ignoring case and whitespace).

Scoring
The submission that produces unique valid outputs in the most languages wins. In case of a tie, the shortest of the tied entries in bytes wins.
1. Yes, turkey is not the only main dish, but we're going to pretend it is.

Two related challenges: 1, 2

Case and whitespace do not matter So can we remove whitespace? Say output cornbread

@LuisMendo Yup.

Related.

"turkey is not the only main dish" But it is the most traditional.

Would an answer involving different dialects of a language count? Like shell scripts (bash, fish, cmd, etc.), or the various dialects of ECMAScript (JavaScript, ActionScript, etc.)?

Well, I'll bring nothing, because I don't live in USA. XD

Can we output extraneous null chars? (0x00)

Also, can we use BF derivatives with BF?

@AlexanderO'Mara Yes, you can use different dialects.

@ConorO'Brien I'll allow the null char as whitespace. And yes, you may use different "dialects" of BF.

Is it ok if my BF program takes input, but then deletes it, so that it will produce the same output even no matter the input?

@KritixiLithos Submissions should be run with no input, so as long as it works with empty input, yes.

So this is basically asking us to code a Turducken.

Pyke, Pyth, Python 2, Foo, Brain****, GolfScript, Actually, <><, Gol<><, Seriously, Befunge, Fission, Haystack, 13 languages, 546 bytes
When I saw the other 10 11 12 language answer, I had to add an extra one two 3. I'm also seriously considering dropping Pyth if only to save on bytes. (at the moment 162 of them)
#\ s[\g\r\a\v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'
print'corn'#))))))))))))))))))))))))]+[--------->++<]>+w.q++[->+++<]>++w.q+++++++++++w.q-----------w.q----------------;))!+f'!n'!i'!s'!s'!e'!r'!d'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))L
'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))
#\25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c|000000
# ,,,,,,,,@0>00000000\#"biscuits"aetteews"

Pyke: Try it here! rolls
Relevent line of code:
#s[\g\r\a  \v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'

#s[\g\r\a  \v\y)w.q) - effectively a comment because # doesn't do anything with an empty stack
\r\o\l\l\ss - sum("r", "o", "l", "l", "s")
p - print(^)
00/ - raise a ZeroDivisionError to stop running code

Pyth: Try it here! gravy
Relevent line of code:
#s[\g\r\a  \v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'

#...) - while True:
s[\g\r\a  \v\y) - sum(["g", "r", "a", "v", "y"])
w - input()
.q - quit

All the )'s are for Pyth to make it compile without erroring on no input.

Python 2: corn
Line 1 is a whole comment
Line 2 prints "corn" and then has a comment
Line 3 has a string literal and then a comment
Line 4 onwards are comments

Foo: Try It Online! biscuits
Foo prints out anything enclosed in double quotes ("). In this case I was careful to only include languages that could cope with other forms of string input (Special case for Befunge). If there was any text after the final ", that would be printed too.

Brain****: Try It Online! salad
I copied the output of constant string generator. I had to escape all . characters with .q so it would play with Pyth and w. so it would play with Pyke. I added some extra - characters so the cells would get to the right points before printing at another . character in the 3rd line

GolfScript: Try It Online! cornbread
In GolfScript, # is a comment until end of line.
What GolfScript interpreter sees:
#comment
print'corn'#comment
'bread'#comment

In GolfScript, for whatever reason, print takes a string and prints it without a newline. Just having bread is enough to print it as well.

Actually: Try It Online! macandcheese
Relevant line:
'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))

é - clears the stack of whatever junk was on it before.
'i'n'o'r'a+++++ - create string "aroni"
) - rotate entire stack (effectively comments as stack is only 1 long)
♀1X - pop stack (now empty)
'c'a'm++++ - constructs the string "mac"
'e's'e'e'h'c'd'n'a++++++++ - constructs the string "andcheese"
) - rotate stack (reverse)
+ - "mac" + "andcheese"
� - quit

<><: Copy+Paste only turkey

Gol<><: Try It Online! stuffing
As <>< except ` skips the first ' and only outputs enough characters to print stuffing

Seriously: Try It Online! macaroniandcheese
Relevant line:
'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))
é - clears the stack of whatever junk was on it before.
'i'n'o'r'a+++++ - create string "aroni"
) - rotate entire stack (effectively comments as stack is only 1 long)
♀1X - no-op
'c'a'm++++ - constructs the string "mac" + "aroni"
'e's'e'e'h'c'd'n'a++++++++ - constructs the string "andcheese"
) - rotate stack (reverse)
+ - "macaroni" + "andcheese"
. - print stack
0\ó - exit

Befunge: Try It Online! sweettea
Code that is looked at
#s[\g\r\a  \v - |
            ) - | - Directing the stack pointer to the correct place
            é - |
# ,,,,,,,,@0>00000000\#"biscuits"aetteews"

            >                              - change direction of travel
             00000000\#"biscuits           - a load of no-ops `#` skips the opening `"`
                                "aetteews" - add the chars to the stack in reverse order
  ,,,,,,,,@                                - output 8 chars from the stack and exit.

Fission: Try It Online! dressing
Code looked at:
;))!+f'!n'!i'!s'!s'!e'!r'!d'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))L

Of which are used:
;!+f'!n'!i'!s'!s'!e'!r'!d'L
                          L - start an atom going left
                      !d'   - create the character `d` and print it
                              ...
;                           - exit

Haystack (2015): PECANPIE (with EXTRA newlines!)
#\
 r
 b
 \25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c

Of which do something functional:
  25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c

I construct each upper case ascii codepoint for the letters in PECANPIE  in uppercase because they're all below 100. I then print them all out as characters.

Wow! Never seen a Pyth/Python polyglot (I guess comments make it easier)

You can remove some spaces and probably make it shorter (macaroni and cheese can be output as macaroniandcheese)

@Artyer spaces removed

@Artyer this ain't no codegolf

@Flp.Tkc Oops. I got confused by all the byte counts. But until there is a 7 language solution:  "In case of a tie, the shortest of the tied entries in bytes wins."

What does it output for Seriously? Also, an explanation would be handy

@KritixiLithos explanation for all added

Wait, GolfScript outputs cornrolls? That wasn't on the menu...

@ETHproductions that's fixed now - how did you spot that?

Just looking through the explanations and I noticed cornrolls as one of the output. Great job fitting all these languages together!

All right then, competition's on! :)

@muddyfish perhaps, if you want to expand this answer in SILOS print (ingredient) will work and not be broken by the other languages. However, are these languages tolerant of having excess garbage at the end.

CJam, 05AB1E, Dip, V, 4 languages, 36 34 bytes
2 bytes saved thanks to @DrMcMoylex!
"turkey"e#"corn"??"gravy"p&Ssalad

Original 36 byte code:
"turkey"e#"corn"??"gravy"p&ddisalad

After the & and before the d there is an <ESC>, which is 1 byte. So the code with the zero-width characters revealed looks like this:
"turkey"e#"corn"??"gravy"p&Ssalad

CJam
(<ESC> is not shown)
"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           e# push this string
        e#"corn"??"gravy"p&Ssalad  e# comment
                                   e# implicit output

Try it online! outputs turkey
05AB1E
(<ESC> is not shown)
"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           # push this string
                                   # STACK: ["turkey"]
        e                          # calculates nPr for the last two values in the stack
                                   # since there is only one value, this evaluates to nothing
                                   # as a result, "turkey" is popped
                                   # STACK: []
         #                         # if true end, since this is false, the program doesn't end
          "corn"?                  # push this string and print it without newlines
                                   # STACK: []
                 ?                 # prints nothing, since there is nothing in stack
                  "gravy"p&Ssalad  # nothing happens here since the stack is already printed using a command and there is NO implicit print now, I think

Try it online! outputs: corn
V
(<ESC> is shown)
"turkey"e#"corn"??"gravy"p&<ESC>Ssalad
"turkey"e#"corn"??"gravy"p&             Code that writes a newline followed by `rn"??"gravy"p&Ssalad`
                           <ESC>        Enters normal mode
                                S       Deletes line and enters insert mode
                                 salad  Writes salad

Try it online! outputs a newline followed by salad
Dip
(<ESC> is not shown)
"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           push this string
                                   STACK: ["turkey"]
        e                          not in the language's database
         #                         push str("turkey") --> "turkey"
                                   STACK: ["turkey"]
          "corn"                   push this string
                                   STACK: ["turkey","corn"]
                ?                  pop "corn", if it is the boolean True (which it isn't) execute the following,
                                   but since it is false, nothing until the next ? gets executed
                                   STACK: ["turkey"]
                 ?                 if-statement end
                                   STACK: ["turkey"]
                  "gravy"          push this string
                                   STACK: ["turkey","gravy"]
                         p&        print turkey and end program
                           Ssalad  irrelevant since program has ended

Outputs gravy

Note: You cannot run python3 dip.py and then type in code for this due to the Escape character literal. It appears as ^[, which makes the Dip interpreter get confused and it thinks that [ is a command, and it results in an error.

The best way to run this is to edit the source file, change the last line in dip.py
main(input(">>> "), stack.Stack())

to
main("\"turkey\"e#\"corn\"??\"gravy\"p&Ssalad", stack.Stack())
exit()

Be sure to include the escape character literal!. Now the code as it is is passed into the interpreter so that it can understand it (" have to be escaped like \" so). Now if you run it from the command-line, it interprets the actual code and outputs gravy.

@ETHproductions I did not see that, anyways working on it...

@ETHproductions Done! Now it works in three languages!

Cool, nice one!

+1 for pop "corn" in the explanation

A nitpick and a golfing tip: it's called "normal mode" not escape mode, and since whitespace is irrelevant, you could change ddi to S

@DrMcMoylex Thanks! I have updated my answer :)

MATL / Golfscript / 05AB1E / CJam: 4 languages, 34 33 bytes
'TURKEY'%"rolls"#];"corn""bread"s

In MATL this outputs TURKEY.
In Golfscript it outputs rolls.
In 05AB1E it outputs corn.
In CJam it outputs cornbread.

Any particular reason for the capitalization of tUrKEY?

@Ethproductions That's so they're valid statements in CJam and it doesn't error out prematurely in that language

Actually it can be all caps. After all, turkey is the most important dish :-)

ferNANDo / ><> / Gol><> / 05AB1E / 2sable, 5 languages, 178 bytes
!v"`"v"!
     <;ooooo"salad"
"<;oooooooo"dressing
1 0
0 1 1 1 0 1 0 0
0 1 1 1 0 1 0 1
0 1 1 1 0 0 1 0
0 1 1 0 1 0 1 1
0 1 1 0 0 1 0 1
0 1 1 1 1 0 0 1
")\"corn""ab"û"aba"Qi"rolls"

ferNANDo: turkey
><>: salad
Gol><>: dressing
05AB1E: rolls
2sable: corn

C, sh, Python 3, Nim, Julia, Brainf**k -- 6 languages, 211 209 bytes
#define println(x) main(){puts("turkey");}/*
#[
#=
a=''''
echo gravy
'''
println=lambda x:print("biscuits")
# ]#proc println[T](s:T)=echo"rolls"#--[----->+<]>---.++++++++++++.+++.----.
# =##*/
println("salad")

Languages to menu items:

C outputs turkey
sh outputs gravy
Python 3 outputs biscuits
Nim outputs rolls
Julia outputs salad
Brainf**k outputs corn

Added Julia thanks to @kvill!

Julia is possible to squeeze in, for the same bytecount. You can drop the C #include (works in gcc). Rename puts println everywhere except in main(), add julia's multiline comment opener #= above a=''' and change #*/ to # =##*/.

You can golf this further by removing the exit and joining the single quote to the previous line (a=''''). sh will issue warnings but this is allowed AFAIU. And oh, println[T](s:T)=echo"rolls" works for Nim. Nice answer with all my favorite languages combined!

Befunge-98, ><>, V, Python 2, 05AB1E, Gol><>, Foo, Haystack (the 2015 version), GolfScript, BF, Fission, Minkolang 0.15, Seriously, Axo: 14 languages,  381 bytes
This is a collaborative answer with BlueEyedBeast
I decided to do a 2D approach to this question... Yes, there are 7 2D esolangs!
I have taken inspiration for additional languages to add by BlueEyedBeast's answer (Foo, GolfScript)
<ESC> is the character literal for Escape.
#>!>\'n\'r\'o\'c\,,,,,@'s'a'l'a'dJ,é'g'n+'i+'s+'s+'e+'r+'d+.ó[-]+[----->+++<]>.+++++++++++.+++[->+++<]>++.+[--->+<]>.+++H'turkey'~;oooooooo'sweettea.0-5++++++++fffffffff''`'
#   >99*d1+c3-c89*4+dcc99*2+c!|$l9D3-O93++dOO8+O1+O1-O5+OO1+O95++O.
# >'p'()'u'()'m'()'p'()'k'()'i'()'n'()'p'()'i'()'e'()\
print'biscuits';'pecanpie'#"stuffing"R'c!'o!'r!'n!'b!'r!'e!'a!'d!*<ESC>ddddddSapplepie

Befunge-98
#?!>                                nothing important
  'n                                push 'n'
                                    STACK: [110]
    \                               swap top two stack values (TBH, I'm not really sure what happens in this case)
                                    STACK: [110, 0]
     'r\'o\'c\                      repeat the same for other characters
                                    STACK: [110 114 111 99 0]
              ,,,,,                 output the next 5 top stack values, "corn"
                   @                end program
                                    rest of the code is irrelevant
                                    since program has already stopped

Try it online! outputs corn
><>
Commands are shown in the order they appear
                                    enter from the left, direction = right
#                                   mirror, now the direction will change to left
                                    and it wraps around and comes to the right
                                    and reads code from the right to the left
'`'                                 push this
   ' ... 5-0.aetteews'              push this too
                      oooooooo      outputs the top 5 characters of the stack
                              ;     end program

Try it online! (Copy and Paste only) outputs sweettea
V
             ...<ESC>                 writes stuff over three lines and enters normal mode
                     ddddddS          deletes 3 lines, delete another line and enter insert mode
                            applepie  writes "applepie"

Try it online! outputs applepie (it might take ˜20 seconds for it to run)
Python 2
                                    # first two lines are comments
print"biscuits";                    # prints "biscuits" and ends statement
                'pecanpie'          # dangling (and ignored) string literal

Try it online! (Copy and Paste only) outputs biscuits
05AB1E
#>!>                                # does nothing important
\'n\                                # push 'n' and delete it
     'r\'o\'c\                      # repeat for other characters
              ,,,,,                 # prints 5 times (since there is nothing in stack,
                                    #                 prints nothing)
                   @                # push the index of the top of stack
                    's'a'l'a'd      # push these characters
                              J,    # join them and print them out
                                    # the rest of the code does not matter
                                    # since there is no implicit print
                                    # because we used the print statement

Try it online! outputs salad
Gol><>
Commands are shown in the order they appear
                                    enter from the left, direction = right
#                                   mirror, now the direction changes to left
                                    and it wraps around and comes to the right
                                    and reads code from the right to the left
 '                                  starting parsing strings
  `                                 escape next character
   '                                gets escaped
    "                               stop string parsing
     fffffffff                      pushes 15, 8 times
           ++++++++                 adds up the numbers, resulting in 135
                 5-                 subtract 4 from it, 130
                   0                pushes 0
                    0               jumps to (130, 0)

#\'n\'r\'o\'c\,,,,,@'r'o'l'l'sJ, ... H'turkey'~;oooooooo"sweettea.0-5++++++++fffffffff""`"
                                              ^
                                       we are here now

                     ˜              removes value at top of stack, '"'
                      "yekrut"      push this string
                              H     Output stack as characters and halt program

Try it online! outputs turkey
Foo
Foo outputs anything in double quotes, that is why I have been careful to not use any double quotes in the other languages. Since "stuffing" is in double quotes, it will be printed.
Try it online! outputs stuffing and then has an error
Haystack (2015)
This uses Haystack's 2015 (not 2016) interpreter since the newer version is invalid. The interpreter for this is haystack.py and not haystack_new.py
Commands are shown in the order they appear
#                                 ignored
 \                                reflection (now it moves downwards)
  >                               set direction to right
   99*d1+c                        Output 'R'
          3-c                     Output 'O'
             89*4+dcc             Outputs 'L', newline, 'L'
                     99*2+c!|     Outputs 'S' and ends the program
                                  Note: '!' is ignored by the interpreter

This program outputs
R
O
L
L
S

and a newline after this output (hey, whitespace doesn't matter!)
GolfScript
                                    first 2 lines are comments
print'biscuits';                    pushes "biscuits" to the stack and discards it
                'pecanpie'          push this
                          #...      comment
                                    implicit output

Try it online! outputs pecanpie
BF
I used https://copy.sh/brainfuck/text.html to convert text into BF. Although there are a lot of , input statements, the BF code runs independent of it.
Try it online! outputs gravy
Fission
For a Fission program to begin, an atom has to be spawned. We see this happening the the third line:
..."stuffing"                                Blah blah blah
             R                               Spawns an atom with direction right
              'c                             Gives the atom the mass of 'c''s ASCII value
                !                            Print the atom's mass
                 'o!'r!'n!'b!'r!'e!'a!'d!    Do the same for other characters
                                         *   Destroy atom, end program

Try it online! outputs cornbread
Minkolang v0.15
#                                Doesn't really do anything
 \                               Reflect, moves downwards
  >                              Changes direction to right
    ... !|                       Does stuff in stack, '!' ignores the '|'
          $l9D3 ... ++O          Uses ASCII character codes to print "applecider"
                       .         Ends program

Try it online! outputs applecider
Seriously
é                          - clear stack
 'g'n+'i+'s+'s+'e+'r+'d+   - load chars onto stack
                        .  - print stack
                         ó - exit

Try it online! outputs dressing
Axo
(Commands are shown the order they are encountered)
#>                                          blah blah
  !                                         rotate direction 90 degrees clockwise

  >                                         go right
   'p'()                                    push char and output
        'u'() ... 'e'()                     repeat for other characters
                       \                    end program

Try it online! outputs pumpkinpie

This is pretty awesome :)

@ETHproductions Thanks! I put a lot of effort into it :)

Just a little nitpick: the ! In the befunge code takes a 0 from the top of the stack and pushes 1. Therefore, the stack contents when the program starts printing is [110 114 111 99 1]. The character for ASCII value 1 isn't visible (start of heading), so it doesn't visually affect the result. +1

@MistahFiggins I could just change it to $,,,, instead to not output the 1 (without changing the bytecount), but then I would have to change all the permalinks... :)

Pushy, Python and Brainfuck
This is my first polyglot, so don't go too hard on me...
For those whining about byte count, it's 77 bytes, but that's only relevant for the tiebreaker.
"`turkey`"
print('gravy')
#++++++++++[>++++++++++<-]>-.++++++++++++.+++.----.

Pushy prints 'turkey' with a leading newline (as well as a message to STDERR):
"        % Print current stack: just a newline as stack is empty
`turkey` % Push to stack
"        % Print the stack: 'turkey'
p        % Primality check on 'y' (121): pushes 0
r        % Integer root of 0: throws error and exits

Python prints 'gravy', as the first and last lines are treated as comments.
Brainfuck ignores all other characters and except for those on the final line, which create and print the word 'corn'.

What's the byte count?

Also, can't you use Python 2 to remove the parenthesis and save 2 bytes?

@KritixiLithos this isn't codegolf....

“In case of a tie, the shortest of the tied entries in bytes wins.” It's not entirely codegolf, but you still need the bytecount.

@TùxCräftîñg true, but this has no chance of getting to the tiebreaker anyway

Pip, BF, oOo CODE, ><>, Befunge-93 (Quirkster implementation), Ouroboros, ///: 7 languages, 175 bytes
/'//bisCuItS/`f(>-[--[<]>+>-]<.++++++++++++.+++.----.O@,,,,,,"tuRkey"
"saLaD"1/ooooo;1(
>"YVaRg"^(OoooOoOOoooOoooOOoooOOoOooOooOooOOoOooOooOooOOoOOoOoOOoOOoOOoOOo`OO"sTUfFINg"

Pip
Try it online
A bunch of expressions that get silently discarded (most of which generate warnings, if warnings are enabled), with the expression "sTufFINg" at the end which gets printed.
/ '/ / b      Invert the string "/" and divide it by nil
i s           Two different variables
Cu            Chr(nil)
It            If 10:
S / `...` OO   Invert a Pattern literal and swap it with undefined variable OO
"sTufFINg"    Autoprint this last expression

BF
Try it online
Everything except >-[--[<]>+>-]<.++++++++++++.+++.----.,,,, is comments. This code generates 99 (the character code for c) via the shortest method listed on esolangs.org, then modifies it for o, r, and n. The ,,,, tries to input four characters, but that doesn't affect anything.
oOo CODE
Everything except letters is ignored. Grouping the letters into threes, the codes reads like this:
bis CuI tSf Otu Rke ysa LaD ooo ooY VaR gOo ... OsT UfF INg

and translates to this BF code (try it using Martin's Retina translator):
>+[-->+><+[<]>-]>.---.---..+++++++.

which outputs rolls. (And, interestingly enough, is shorter than the above BF for outputting corn, even with a >< no-op added to make the capitalization line up correctly.)
><>
Run ><> code here
The important part of the code:
/
        /ooooo;
>"YVaRg"^

The IP gets reflected upward, wraps around, and gets sent rightward. "YVaRg" pushes the character codes of gRaVY. ooooo outputs five letters and ; terminates the program.
Befunge-93
The code depends on undefined behavior and probably only works in this implementation.
The important part of the code:
/'                        @,,,,,,"tuRkey"

/ is division. The stack is empty, so the JavaScript implementation I'm using divides 0 by 0 and pushes NaN.
' is an unrecognized character. The implementation I'm using, conveniently, treats unrecognized characters as Reflect commands. (For a less implementation-dependent version, one possible replacement would be 1_.) So the IP goes left again, divides NaN by 0 (getting NaN), and wraps to the other end of the line.
Now "yekRut" (moving RTL) pushes the character codes of tuRkey and ,,,,,, outputs them. Finally, @ terminates the program.
Ouroboros
Try it here
Each line of the code is a "snake" that executes independently.
Snake 1
Since there are no output instructions, the only important part of the code is f(: f pushes 15 and ( swallows that many characters from the end of the snake. The code is now considered to end after .O. Execution continues until the end of the snake and loops back to the beginning. Each time through, the snake gets shorter, until eventually the ( is swallowed. Since the IP just got eaten, the snake halts execution.
Snake 2
"saLaD" pushes its character codes last-to-first; 1/ divides the charcode of r by 1, leaving it unchanged, and ooooo outputs five characters. ; drops an item (no-op because the stack is already empty). 1( swallows the instruction pointer and halts.
Snake 3
"YVaRg" pushes some charcodes; then ( swallows a number of characters equal to the top of the stack, which happens to be 89, the character code of Y. Eating 89 characters is enough to swallow the IP and halt execution.
///
Try it online using my Pip implementation of ///
/'// deletes all single quotes from the rest of the program (which does nothing because there aren't any). Next, bisCuItS outputs as-is. Finally, the rest of the code is an incomplete substitution--there's only two of the three requisite slashes--so it does nothing.

I like the abuse of the "case doesn't matter" rule to make it work in oOo CODE :-)

Cubix, Pushy, Brainfuck, V, Python 2 - 5 languages, 89 85 bytes
My second ever polyglot - not very golfed, but it works:
"`turkey`";print'salad'#;"nroc"w!@o;"-[--";;;;{{->+<]>---.---.---..+++++++.␛ddgigravy

(note that ␛ represents the literal escape byte, x1B)

Cubix prints corn
Pushy prints turkey
Brainfuck prints ROLLS
V prints gravy
Python prints salad

Cubix
Test the program online!
Cubix is a language by the challenge author, ETHproductions. The Cubix Interpreter reads the code like this:
        " ` t u
        r k e y
        ` " ; p
        r i n t
' s a l a d ' # ; " n r o c " w
! @ o ; " - [ - - " ; ; ; ; { {
- > + < ] > - - - . - - - . - -
- . . + + + + + + + . d d g i ␛
        g r a v
        y . . .
        . . . .
        . . . .

The code is executed like so:

'salad - does some irrelevant XOR operations on stack, results in 115, 0, 0
'#; - push the charcode of #, then pop it again (no-op)
"nroc" - push the charcodes for "corn"
w - moves the IP to loop on the next line below:

!@o; - print and pop last item (terminate if item is 0)
"-[--";;;; - push these chars and delete them (no-op)
{{ - no-op

Pushy
Test the program online!
Pushy is my own language, and it runs the code like this:
"          \ Print stack. Empty, so prints newline.
`turkey`   \ Push this string
"          \ Print this string
;          \ "End loop": Ignored as there is no loop in progress.
pr         \ Irrelevant stack operations
i          \ "interrupt": exit program.

Brainfuck
Test the program online!
Brainfuck ignores all characters that are not in its list of instructions, resulting in:
-[--->+<]>---.---.---..+++++++.

Which prints ROLLS. Note that this requires an interpreter with wrapping cells, such as the one provided.

V (Vim language)
Test the program online!
V was created by DJMcMayhem, one of our top code-golfers.
V is a program-based version of the text editor Vim. Most characters before the ESC get written into the "file", but ␛ddgigravy deletes all of that and inserts "gravy" instead. The content of the file at the end of the program is printed.

Python 2
Test the program online!
Python is one of my favorite practical languages. Because # is a comment in Python, most of the program is ignored. The code is read like this:
"`turkey`";            # Unused string literal
print'salad'           # Print statement
#...                   # Comment (everything else is ignored)

Minor nitpick: 'salad'# actually pushes the charcode of s, 0, 0, and the charcode of #, then ; pops and leaves the stack at 115,0,0.

@ETHproductions yeah, you're right, doesn't affect the program either way really but I'll fix up the description

Python/QBasic/Pip, 3 languages, 41 bytes
More languages possibly TBA.
1#print"corn":end
print("turkey");"salad"

Python
1 is just an expression that gets discarded. # starts a comment. print("turkey") does what it says, and "salad" is another expression that gets discarded.
QBasic
1# is a (double-precision) line number. print"corn" does what it says. end terminates the program. The second line is syntactically valid but never executed.
Pip
Most everything is expressions that get discarded. "corn":e tries to assign to a literal string, which fails silently (unless warnings are enabled). "salad" is the last expression in the program and therefore is printed.

PHP, JavaScript and BrainF*ck, 178 Bytes
First time I've ever tried a Polyglot - not going to lie, I'm in over my head here...
Golfed:
<!DOCTYPE html><html><body><?php echo "turkey";?></body><script>function A(){alert("stuffing");}//`--[----->+<]>-++.+++++++++++.-----------------.-----------.+++.`
</script></html>

(I didn't dare to write a Thanksgiving food in the HTML code and count that as another language...)
Explanation:
The code needs to be saved into a .php file for the PHP and JavaScript parts.
PHP:
When ran on a PHP server, the PHP part of the code is read:
<?php echo "turkey";?>

This outputs:

JavaScript:
You can call the JavaScript A() function from the browser console:
function A(){alert("stuffing");}

This outputs:

Brainf*cK
The Brainf*ck part is nicely hidden in the comments in the JavaScript section, so it is ignored by the PHP and JavaScript parts:
--[----->+<]>-++.+++++++++++.-----------------.-----------.+++.

When the whole file pasted into an IDE, this outputs:

I couldn't have done the Brainf*ck part without this text-to-BF website. I originally got it to generate code for "corn" and then in an attempt to learn something about this crazy language, I converted it to "gravy"...or rather "graVY"...

Python, Clojure, Javascript, Ruby: 4 languages, 113 bytes
1;''''/*
#_(
puts("turkey")
__END__
);'''
1;1//2;'''
1;*/alert("gravy")/*
(print "salad");'''
#_
print "corn";#*/

Thanks to @Sp3000 for most of the code. Surprisingly, I didn't even have to do anything to his original, I just had to prepend the Ruby code.

///, SQL and JavaScript
/*//turkey/\*/select('corn')
--a;function select(){alert('salad')}

Same construction as with that other holiday-oriented polyglot:
///
/*//turkey/../..   Simply prints 'turkey', does no replaces, stops execution because the second /// block is incomplete

SQL
/*//turkey/\*/    //turkey/\ is seen as a block comment
                  That last \ was added to set apart the following */, completing the block
select('corn')    SQL Select statement, yielding 'corn'
--a;...           Seen by SQL as a comment, ignored

Javascript
/*//turkey/\*/    //turkey/\ is seen as a block comment
select('corn')    Function call to the function 'select', defined below
--a;              Decrement a, effectively a NOP
function select(){alert('salad')}
                  Defines the function select(), giving us 'salad'

Clojure / Common Lisp / PicoLisp, 39 bytes
(print(if '()'turkey(if""'rolls'corn)))

Lisp family here. '() evaluates to true in Clojure so it proceeds to outputing a symbol turkey. PicoLisp and Common Lisp goes into false branch; "" is true in Common Lisp and thus it prints symbol rolls, empty string is false in PicoLisp and so it goes to printing corn symbol.
Check it online:
https://ideone.com/OD65LB - Clojure
https://ideone.com/M1H5gf – Common Lisp
https://ideone.com/B4x3ns – PicoLisp

CJam, Underload, ><>, 39 bytes
'v;"(Turkey)S";"Gravy""
 >'nroC'oooo;";

What CJam sees

'v;: A character literal that is immediately discarded
"(Turkey)S";: A string literal that is immediately discarded
"Gravy": Pushes the string Gravy to the stack
"\n'nroC'oooo;";: A string literal that is immediately discarded.

At the end of execution, the stack is output, which means that "Gravy" is printed.
What Underload sees

'v;": Some invalid commands that are ignored
(Turkey)S: Pushes the string "Turkey" and outputs it
";"Gr: Some invalid commands that are ignored
a: This causes a segfault on the TIO interpreter since the stack is empty. Execution is terminated.

What ><> sees

'v;"(Turkey)S";"Gravy"" pushes a bunch of characters to the stack (which are ignored). The IP then wraps back around.
v sends the IP downwards.
>'nroC'oooo pushes the characters in the string "Corn" and outputs them.
; terminates execution. All other characters are ignored.


text:
Convert CSV to Table
The Challenge
Given a CSV input, output a proper unicode table using box characters.
Formatting
The table will be formatted using the following rules:

Column width will be equal to the longest value of that column
All table data will be left justified
Each table will assume the first csv row to be the header
The table will use the following characters for its borders:

┌  ┬  ┐  ├  ┼  ┤ └  ┴  ┘   ─  │
Example
Input:
Name,Age,Gender
Shaun,19,Male
Debra,19,Female
Alan,26,Male
George,15,Male

Output:
┌──────┬───┬──────┐
│Name  │Age│Gender│
├──────┼───┼──────┤
│Shaun │19 │Male  │
│Debra │19 │Female│
│Alan  │26 │Male  │
│George│15 │Male  │
└──────┴───┴──────┘

Rules

Standard loopholes apply
You may submit a full program, a function or a lambda
Input can be from a file, a program argument or any acceptable alternative
Output can be to a file, returned or any acceptable alternative
CSV input should take the same format as used in my example.
Shortest answer in bytes wins.

CSV input should take the following form:
Header1,Header2,Header3 newline
Column1,Column2,Column3 newline
Column1,Column2,Column3 optional_newline

Can you explain the CSV format you expect, and/or limitations in input?  CSV in itself is ambiguous as a format specification.

What characters can appear in the CSV fields?

I think there are basically two ways you can go with the CSV definition. If the interesting part of the problem is the output, you can make it as simple as "split on commas" and not have to worry about how to quote commas and how to quote the quote character. Otherwise, you could state a specific method of parsing the CSV ("double quotes toggle a mode in which commas are ignored, two double quotes in a row produces a literal double quote" is a fairly common one, but by no means the only one in existence).

Err, serious problem: you haven't specified a victory condition. What are the programs meant to be optimized for? Length ([tag:code-golf])?

Relevant information: 1, 2, 3, 4.

At least the first three links there all define CSV differently (and at least two say that there are lots of different ways to do it). So I'm assuming that "CSV" needs to be more fully defined for use in a question (and that the solutions will try to get away with splitting on commas and not handling escaping because it allows them to be shorter).

Okay I've edited the question to include specifics about the CSV format I would like everyone to use.

CRLF? Seriously? That's going to give a fairly large penalty on Unix, where CR means something else in text files. You probably want to just replace that with "newline", allowing the OS-specific newline to be used.

Is input using list or array of strings (and no newlines) valid?

@edc65 Nope....

So APL and C# answers are invalid

May the last input line have a newline like the other lines?

@Adám I will allow it.

Try (Dyalog) APL, 38 43 bytes
Last input line must have a trailing newline.
{{(⊃⍵)⍪⍉⍪↑¨↓⍉↑1↓⍵}s¨',',¨(s←1↓¨⊢⊂⍨⊢=⊃)¯1⌽⍵}

Try it online! In the offline version of Dyalog APL, execute ]boxing ON -style=min for the same effect.
Explanation
{ ... } an anonymous function where ⍵ represents the argument:
 ¯1 ⌽ ⍵ rotate the trailing newline to the front
 (s ←  ... ) define the function s as follows, and apply it
  1 ↓¨ drop the first character of each
  ⊢ ⊂⍨ line, split where
  ⊃ = ⊢ the first character equals the characters in the string
 ',' ,¨ then prepend a comma to each line
 s¨ apply the function s to each line
 { ... } now apply the following anonymous function:
  1 ↓ ⍵ drop the first element (the row headers)
  ↓ ⍉ ↑ transpose the list of rows into list of columns
  ↑¨ make each element (a list of entries) into a matrix of padded entries
  ⍉ ⍪ make into one-column matrix, then transpose into one-row matrix
  (⊃⍵) ⍪ put the argument's first element (the list of headers) on top`
Note: While the line drawing characters are not explicitly used in my solution, they are part of the APL character set, and would also be counted as single bytes.

See comments above Is input using list or array of strings (and no newlines) valid? Nope.

@edc65 Fixed. Thanks.

Hah, that boxed display surely comes in handy :)

PowerShell 3+, 365 bytes
$d=$input|ipcsv
$h=$d[0].PSObject.Properties.Name|%{$_|Add-Member -type NoteProperty -na c -v(($d.$_+$_|measure Length -ma).Maximum)-pa}
"┌$(($h|%{'─'*$_.c})-join'┬')┐"
"│$(($h|%{$_.PadRight($_.c)})-join'│')│"
"├$(($h|%{'─'*$_.c})-join'┼')┤"
$d|%{$i=$_;"│$(($h|%{$i.$_.PadRight($_.c)})-join'│')│"}
"└$(($h|%{'─'*$_.c})-join'┴')┘"

I feel like this could be improved a lot but I ran out of time. All line endings are \n with no \r, encoding is UTF8 with no BOM.

APL (Dyalog Extended), 36 25 bytesSBCS

Full program. Assumes that ABCDEFGHIJKLMNOPQRSTUVWXYZ is the CSV file. Prints to stdout.
⌂disp(1↑m)⍪↑¨↓⍉1↓m←⎕CSV⎕A

Try it online!
⎕A the uppercase Alphabet (the shortest-to-reference built-in string)
⎕CSV read that file and convert from CSV to matrix
m← store as m (for matrix)
1↓ drop the first row
⍉ transpose
↓ split into list of columns
↑¨ mix each list of strings into a matrix
(…)⍪ stack the following on top of that:
 1↑m take the first row of m
⌂disp apply dfns.disp to that
(draws line drawing characters)

JavaScript, 261 bytes
(t,[H,...D]=T=t.split`
`.map(r=>r.split`,`),w=H.map((_,i)=>Math.max(...T.map(r=>r[i].length))),L=(x,i,_,[[[a,b=a,c=a]],p]=1/i?`│`:[x,'─'])=>a+w.map((n,j)=>(p?'':x[j]).padEnd(n,p)).join(b)+c+`
`)=>L`┌┬┐`+L(H,0)+L`├┼┤`+D.map(L).join``+L`└┴┘`

Try it online!
Ungolfed and explained
(
  tableCSV,
  [header, ...data] = table = tableCSV.split(`\n`).map(row => row.split(`,`)),
  widths = header.map((_, i) => Math.max(...table.map(row => row[i].length))),
  drawLine = ( // create data row or border
    x, // either data array or singleton string array
    i, // either data index or undefined
    _, // ignored (data.map(drawLine) sets this to data)
    [[[a, b = a, c = a]], pad] = 1 / i ? `│` : [x, '─']
       // a = start, b = separator, c = end, pad = '─' if making border
  ) =>
    a +
    widths.map((n, j) => (pad ? '' : x[j]).padEnd(n, pad)).join(b) +
    c +
    `\n`
) =>
  drawLine`┌┬┐` +
  drawLine(header, 0) +
  drawLine`├┼┤` +
  data.map(drawLine).join(``) +
  drawLine`└┴┘`

JavaScript (ES6|FireFox), 286 bytes
f=>(d=f.split`
`.map(a=>a.split`,`),s=d[0].map((a,i)=>d.reduce((b,c)=>(n=c[i].length)>b?n:b,0)),d=d.map(a=>`│${a.map((b,i)=>b.padEnd(s[i])).join`│`}│`),d.splice(1,0,(g=h=>h[0]+s.map(a=>'─'.repeat(a)).join(h[1])+h[2])('├┼┤')),g('┌┬┐')+`
${d.join`
`}
`+g('└┴┘'))

Uses padEnd, which is FireFox specific.

Isn't this 288 bytes?

@Adám ...yes... Fixed

You use this alot, isn't g('└┴┘') equivalent to g└┴┘ (with backticks after g and at the end)?

@NoOneIsHere Unfortunately not. Passing it in raw like that treats all 3 as a single character (so h[0] contains all 3, and h[1] is undefined).

padEnd is non-standard. You should specify the necessary execution environment.

Also, there are a couple of places where you write \foo`+bar+`baz`- you can save a byte by using a template`foo${bar}baz``.

@Mwr247 You can use @NoOneIsHere's suggestion g\└┴┘`by changingg=h=>h[0]+...tog=([h])=>h[0]+...`, which probably saves more bytes than it adds to the definition (I haven't checked)

JavaScript (ES6), 281 bytes
Note: input as a single string with newlines - as requested by OP. Other answers use a string list - using a string array in input I can avoid the first split and cut 9 bytes.
l=>(l=l.split`
`.map(r=>r.split`,`.map((w,i)=>(v=w.length)<c[i]?w:(c[i]=v,w)),c=[k=0]),l=l.map(r=>r.map((v,i)=>(v+' '.repeat(c[i]-v.length)))),[h=c.map(x=>'─'.repeat(x)),l.shift(),h,...l,h].map(a=>'│┌├└'[j=a!=h?0:++k]+a.join('│┬┼┴'[j])+'│┐┤┘'[j]).join`
`)

Less golfed
l=>(
  // split input in an array of string arrays
  // meanwhile find the column widths and put them in *c*
  l = l.split`\n`.map(r=>r.split`,`.map((w,i)=>(v=w.length)<c[i]?w:(c[i]=v,w)),c=[]),

  // pad each column to the max column width
  l = l.map(r=>r.map((v,i)=>(v+' '.repeat(c[i]-v.length)))),

  // put in *h* the horizontal lines for top,bottom and head separator
  h = c.map(x => '─'.repeat(x) ),

  // add the *h* line at top, bottom and after head line
  l = [h, l.shift(), h, ...l, h],

  // rebuild a string, joining columns with '|' unless the row is *h*
  // if the row is *h* use different characters to join columns
  k = 0,
  l.map(a=> '│┌├└'[j=a!=h?0:++k] + a.join('│┬┼┴'[j]) + '│┐┤┘'[j])
  .join`\n`
)

Test

F=
l=>(l=l.split`
`.map(r=>r.split`,`.map((w,i)=>(v=w.length)<c[i]?w:(c[i]=v,w)),c=[k=0]),l=l.map(r=>r.map((v,i)=>(v+' '.repeat(c[i]-v.length)))),[h=c.map(x=>'─'.repeat(x)),l.shift(),h,...l,h].map(a=>'│┌├└'[j=a!=h?0:++k]+a.join('│┬┼┴'[j])+'│┐┤┘'[j]).join`
`)

function update() {
  O.textContent = F(I.value)
}
update()
#I { width:60%; height: 8em}
<textarea id=I>Name,Age,Gender
Shaun,19,Male
Debra,19,Female
Alan,26,Male
George,15,Male</textarea>

<button onclick='update()'>Go</button>

Racket 578 bytes
(let*((ll(map(λ(x)(string-split x","))ll))(lr list-ref)(sl string-length)(d display)(dl displayln)(nc(length(lr ll 0)))
(nl(for/list((i nc))(apply max(for/list((j ll))(sl(lr j i))))))(pl(λ(sy)(d(lr sy 0))(for((n nc))(for((m(lr nl n)))(d(lr sy 1)))
(if(< n(sub1 nc))(d(lr sy 2))(dl(lr sy 3))))))(g(λ(i n)(for((m(-(lr nl n)(sl i))))(d" ")))))(pl'("┌""─""┬""┐"))
(for((i(lr ll 0))(n(in-naturals)))(d"│")(d i)(g i n))(dl"│")(pl'("├""─""┼""┤"))(for((j(range 1(length ll))))
(for((i(lr ll j))(n nc))(d"│")(d i)(g i n))(dl"│"))(pl'("└" "─" "┴" "┘")))

Ungolfed:
(define(f1 ll)
 (let* ((ll (map (λ (x)(string-split x ",")) ll))  ; use this to convert csv format to list of lists;
         (lr list-ref)                    ; make short names of standard fns
         (sl string-length)
         (d display)
         (dl displayln)
         (nc (length (lr ll 0)))          ; number of cols;
         (nl(for/list ((i nc))            ; get list of max string-length for each column
              (apply max
                     (for/list ((j ll))
                       (sl (lr j i))
                       ))))
         (pl (λ (sy)                      ; put lines using sent symbol list
               (d (lr sy 0))
               (for ((n nc))
                 (for ((m (lr nl n))) (d (lr sy 1)))
                 (if (< n (sub1 nc))
                     (d (lr sy 2))
                     (dl (lr sy 3))
                     ))))
         (g (λ (i n)                     ; pad with spaces if needed
              (for ((m (- (lr nl n) (sl i)))) (d " ")) )))
    ; put line above header:
    (pl '("┌" "─" "┬" "┐"))

    ; put header:
    (for ((i (lr ll 0)) (n (in-naturals)))
      (d "│")
      (d i)
      (g i n)
      )
    (dl "│")

    ; put line below header;
    (pl '("├" "─" "┼" "┤"))

    ; put rows:
    (for ((j (range 1 (length ll))))
      (for ((i (lr ll j))
            (n nc))
        (d "│")
        (d i)
        (g i n)
        )
      (dl "│")
      )

    ; put bottom line:
    (pl '("└" "─" "┴" "┘"))
    ))

Testing:
(f (list  "Name,Age,Gender"
          "Shaun,19,Male"
          "Debra,19,Female"
          "Alan,26,Male"
          "George,15,Male"))

Output:
┌──────┬───┬──────┐
│Name  │Age│Gender│
├──────┼───┼──────┤
│Shaun │19 │Male  │
│Debra │19 │Female│
│Alan  │26 │Male  │
│George│15 │Male  │
└──────┴───┴──────┘

PowerShell for Windows, 256...236 238 bytes
$v=$args-split'
'-ne''|%{,($_-split',')}
function z($b,$a){$b[1]+(($v[0]|%{@($a)[$x++]+''|% p*ht($v|%{$_[$x-1]}|% le*|sort -b 1)$b[0]})-join$b[2])+$b[3]}
z '─┌┬┐'
$v|%{z ' │││'$_;if(!$r++){z '─├┼┤'}}
z '─└┴┘'

Try it online!
Notes:

The Sort alias defined for Windows only. It need Sort-Object for Linux instead sort or command set-alias sort sort-object before this script (TIO way).
The p*ht shortcut expands to the PadRight-method for a string.
The le* shortcut expands to the Length-method for a string.

An input csv contains:

comma and newline are delimiters only (no comma and no newline inside values|headers)
spaces in the values|headers are significant letter (keep due justifying)
at least 2 not empty lines (headers and values)
an "optional_newline" at the end
optional empty values|headers
optional empty inner lines

JavaScript (V8), 291 bytes
d=>([h]=r=d.split`
`.map(s=>s.split`,`),l=h.map((_,i)=>Math.max(...r.map(k=>k[i].length))),s=([[x,y,z]])=>h.reduce((a,_,i)=>a+"─".repeat(l[i])+(i==h.length-1?z:y),x)+`
`,[f,...t]=r.map(r=>r.reduce((s,x,i)=>s+x.padEnd(l[i])+z,z="│")+`
`),s`┌┬┐`+f+s`├┼┤`+t.join``+s`└┴┘`)

Try it online!
Not exactly a competitive score compared to the three other answers written in JS (???), but its as good as I can do.
Ungolfed/explained:
csvString => (
  // convert the string into an array of row content arrays (string[][])
  // extracting first element h to save a few bytes off of r[0] later
  [h] = rows = d.split(`\n`).map(s=>s.split(`,`)),
  // get the lengths of the longest entry of each column
  columnLengths = h.map((_, i) => Math.max(...rows.map(row => row[i].length))),
  // build strings for the top line, header separator, and bottom line
  // [[x,y,z]] to extract chars from tagged template literal
  // "─" repeated by the length of the column + correct separator if
  // last/middle character
  buildLine = ([[x,y,z]]) => h.reduce(
    (a,_,i) =>
      a + "─".repeat(columnLengths[i]) + (i === h.length - 1 ? z : y),
    x
  ) + `\n`,
  // get lines that contain data seperated by "│" - f is header, t is rest
  [header, ...rest] = rows.map(row =>
    row.reduce((s, x, i) => s + x.padEnd(l[i]) + z, z = "│") + `\n`
  ),
  // final return value: top row + header + header separator + rest of
  // data + bottom row
  buildLine`┌┬┐` + header + buildLine`├┼┤` + rest.join("") + buildLine`└┴┘`
)

C#, 696 Bytes
Golfed:
string T(string[]f){int w=f.Max(r=>r.Length),a=f.Select(r=>r.Split(',')[0].Length).Max(),b=f.Select(r=>r.Split(',')[1].Length).Max(),c=f.Select(r=>r.Split(',')[2].Length).Max();string o="",n="\r\n",d="",j=string.Concat(Enumerable.Repeat("─",a)),k=string.Concat(Enumerable.Repeat("─",b)),l=string.Concat(Enumerable.Repeat("─",c));Func<string,int,string>z=(q,p)=>{return q.PadRight(p);};d="┌"+j+"┬"+k+"┬"+l+"┐";o+=d+n;var g=f.First().Split(',');o+="|"+z(g[0],a)+"|"+z(g[1],b)+"|"+z(g[2],c)+"|";d="├"+j+"┼"+k+"┼"+l+"┤";o+=n+d+n;for(int i=1;i<f.Length;i++){var h=f[i].Split(',');o+="|"+z(h[0],a)+"|"+z(h[1],b)+"|"+z(h[2],c)+"|"+n;}d="└"+j+"┴"+k+"┴"+l+"┘";o+=d;return o;}

Ungolfed (and nicer, because ^that is no use to anyone):
public string T(string[] c)
{
  int width = c.Max(r => r.Length),
    longestFirstColumn = c.Select(r => r.Split(',')[0].Length).Max(),
    longestSecondColumn = c.Select(r => r.Split(',')[1].Length).Max(),
    longestThirdColumn = c.Select(r => r.Split(',')[2].Length).Max();

  string o = "", lr = "\r\n", border = "",
    firstColumnFiller = string.Concat(Enumerable.Repeat("─", longestFirstColumn)),
    secondColumnFiller = string.Concat(Enumerable.Repeat("─", longestSecondColumn)),
    thirdColumnFiller = string.Concat(Enumerable.Repeat("─", longestThirdColumn));

  Func<string, int, string> padRight = (a, b) => { return a.PadRight(b); };

  border = "┌" + firstColumnFiller
    + "┬" +
    secondColumnFiller + "┬"
    + thirdColumnFiller
    + "┐";

  o += border + lr;

  var firstRow = c.First().Split(',');

  o += "|" + padRight(firstRow[0], longestFirstColumn) +
    "|" + padRight(firstRow[1], longestSecondColumn) +
    "|" + padRight(firstRow[2], longestThirdColumn) + "|";

  border = "├" +
    firstColumnFiller + "┼" +
    secondColumnFiller + "┼" +
    thirdColumnFiller
    + "┤";

  o += lr + border + lr;

  for (int i = 1; i < c.Length; i++)
  {
    var row = c[i].Split(',');

    o += "|" + padRight(row[0], longestFirstColumn) + "|"
    + padRight(row[1], longestSecondColumn) + "|" +
    padRight(row[2], longestThirdColumn) + "|" + lr;
  }

  border = "└" +
    firstColumnFiller + "┴" +
    secondColumnFiller + "┴" +
    thirdColumnFiller
    + "┘";

  o += border;

  return o;
}

Testing:
┌──────┬───┬──────┐         ┌──────────┬───────────────────────────┬─────┐
|Name  |Age|Gender|         |Name      |PPCG Challenge             |Votes|
├──────┼───┼──────┤         ├──────────┼───────────────────────────┼─────┤
|Shaun |19 |Male  |         |Pete Arden| Print all integers        | 4   |
|Debra |19 |Female|         |Pete Arden| Yes of course I'm an adult| 3   |
|Alan  |26 |Male  |         |Pete Arden| 5 Favorite Letters        | 1   |
|George|15 |Male  |         └──────────┴───────────────────────────┴─────┘
└──────┴───┴──────┘

Somehow, I keep getting 697 bytes when counting this.

@Adám Just checked again, the Golfed string is 666 columns long in Visual Studio. But neither 666 nor 697 are exactly competitive scores anyway :)

You have a trailing newline, but even when removing it, it is still 696 bytes.

@Adám Ah... I've been waiting for a letter count/byte count discrepancy to trip me up. Should have known with these funny symbols in this one ("┼"). Updated, thanks :)

See comments above Is input using list or array of strings (and no newlines) valid? Nope.

Perl, 273 + 9 (-CS -nlaF, flags) = 282 bytes
$v[$.-1]=[@F];map$l[$_]<($l=length$F[$_])&&($l[$_]=$l),0..$#F}sub p{printf$p,@_}sub o{p
pop,map{$\x$l[$_],$_-$#l?$_[0]:pop}0..$#l}$p=join'%s','',(map"\%-${_}s",@l),$/;($\,$c,@c)=map
chr$_*4+9472,0,.5,3..15;o@c[8,1,0];p($c,map{$_,$c}@$_),$i++||o@c[12,6,4]for@v;o@c[10,3,2];{

Using:
cat file.csv | perl -CS -nlaF, script.pl

Try it on Ideone.

Python 3, 318 bytes
-3 bytes for using the % formatting and -1 for abbreviating str.join
L=[c.split(',')for c in input().split('\n')]
m=[max(len(x)for x in c)for c in zip(*L)]
L=[[""]+[d.ljust(n)for d,n in zip(c,m)]+[""]for c in L]
g=["─"*i for i in m]
J=str.join
print('\n'.join(["┌%s┐"%J("┬",g),J("│",L[0]),"├%s┤"%J("┼",g)]+[J("│",L[i])for i in range(1,len(L))]+["└%s┘"%J("┴",g)]))

Requires input enclosed in quotes.

Looks like 318 bytes to me.

@Adám You are right, i looked at the chars.

Does not work, because input() only takes one line on each call.
You will need to call input() until there are no more lines, or read directly from stdin.

Besides that: 292 bytes

PHP, 313 bytes
for(;$r=fgetcsv(STDIN);$a[]=$r)foreach($r as$x=>$s)$e[$x]=max($e[$x],strlen($s));$t=["┬","┌","┐"];eval($L='foreach($e as$i=>$n)echo$t[!$i],str_repeat("─",$n);echo"$t[2]\n";');foreach($a as$k=>$r){foreach($r as$i=>$s)echo"│",str_pad($s,$e[$i]);echo"│\n";$t=["┼","├","┤"];if(!$k)eval($L);}$t=["┴","└","┘"];eval($L);

breakdown
for(;$r=fgetcsv(STDIN);$a[]=$r)                         // read csv from STDIN, append to array $a
    foreach($r as$x=>$s)$e[$x]=max($e[$x],strlen($s));  // remember max length in array $e
                                                        // print top border
$t=["┬","┌","┐"];eval($L='foreach($e as$i=>$n)echo$t[!$i],str_repeat("─",$n);echo"$t[2]\n";');
foreach($a as$k=>$r)
{
    foreach($r as$i=>$s)echo"│",str_pad($s,$e[$i]);echo"│\n";   // print row
    $t=["┼","├","┤"];if(!$k)eval($L);                           // print border below header
}
$t=["┴","└","┘"];eval($L);                              // print bottom border

Test it at ideone

C (gcc), 588 bytes
#define H char
P(c,n){for(H*s[]={"\n","┌","┬","┐","├","┼","┤","└","┴","┘","─","│"};n--;)printf("%s",s[c]);}S(s,n)H*s;{printf("%-*s",n,s);}E(n,c,Z,i)int*Z;{for(i=P(3*n+1,1);i<c;P(3*n+(++i-c?2:3),1))P(10,Z[i]);P(0,1);}V(t,c,Z,r,i)H**t;int*Z;{for(i=P(11,1);i<c;i++,P(11,1))S(t[i+r],Z[i]);P(0,1);}f(s,p)H*s,*p;{int r,R,C,i,m,L;R=C=i=m=r=0;for(p=s;*p;*p++==44&&C++)!(p[1]&&*p^10)&&R++;C/=R;H*t[R*++C];for(p=s;i<R*C;*p++=0)for(t[i++]=p;*p^44&&*p^10;)p++;int Z[C];for(i=0;i<C;Z[i++]=m)for(m=r=0;r<R;m=m<L?L:m)L=strlen(t[i+C*r++]);E(0,C,Z);V(t,C,Z,0);for(E(i=1,C,Z);i<R;)V(t,C,Z,C*i++);E(2,C,Z);}

Try it online!

432

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Handling errors
What's great about golfing is not having to deal with errors. Except this time you won't get off so lightly! I need to do some arithmetic with certain limitations, and I wan't to know what goes wrong if anything.
Challenge
Given a list of signed integer values [n1..n11], give the following result or the first error that occurred.
(((((((((n1+n2)-n3)^n4)/n5)*n6)+n7)-n8)^n9)/n10)*n11

The same in reverse polish notation:
n1 n2 + n3 - n4 ^ n5 / n6 * n7 + n8 - n9 ^ n10 / n11 *

The operators have the following limitations:

0^0 → error 0^0 is undefined
0^a when a<0 → error Negative exponent
a/0 → error Division by zero
a/b when mod a b != 0 → error Uneven division
for any operator: result < 0 → error Integer underflow
for any operator: result > 99 → error Integer overflow
for any operator: either input value or result == 13 → error 13 is bad luck!

Errors occur left to right, so 13/0 = error 13 is bad luck!.
Scoring
The shortest code in bytes wins. To encourage readability string literals used for errors won't count towards the score.
The output format isn't strict but all seven errors plus a correct value must be distinguishable. Your program/function must retain control flow until the end, so e.g. any exceptions must be caught.
Standard loopholes are disallowed.
Examples
[6,7,14,2,0,1,2,3,4,0,6]   → error `13 is bad luck!`
[6,6,14,2,0,1,2,3,4,0,6]   → error `Integer underflow`
[6,6,12,0,0,1,2,3,4,0,6]   → error `0^0 is undefined`
[6,6,12,2,0,1,2,3,4,0,6]   → error `Division by zero`
[6,6,10,6,12,1,2,3,4,0,6]  → error `Uneven division`
[6,6,10,6,8,17,2,13,4,0,6] → error `Integer overflow`
[6,6,10,6,8,7,99,13,4,0,6] → error `Integer overflow`
[6,6,10,6,8,7,9,99,4,0,6]  → error `Integer underflow`
[6,6,10,6,8,7,9,55,-2,0,0] → error `Negative exponent`
[6,6,10,6,8,7,9,56,2,0,8]  → error `Division by zero`
[6,6,10,6,8,7,9,56,2,9,12] → error `Integer overflow`
[6,6,10,6,8,7,9,56,2,9,11] → 99

Haskell, 190 186 185 bytes
311 bytes total, 185 bytes without the string literals.
e=Left
0#0=e"0^0 is undefined"
b#_|b<0=e"Negative exponent"
b#a=t$a^b
0!a=e"Division by zero"
b!a|mod a b>0=e"Uneven division"
b!a=t$div a b
t 13=e"13 is bad luck!"
t x|x<0=e"Integer underflow"|x>99=e"Integer overflow"|1<2=Right x
f(x:y)=foldl(>>=)(t x)$zipWith id(cycle[q(+),q(-),(#),(!),q(*)])y
q=((t.).).flip

This wraps the error handling in the Either e monad, i.e. the result is either Left <ErrorMsg> or Right <Number>, for example:
*Main> f [6,6,10,6,8,7,9,56,2,9,11]
Right 99
*Main> f [6,6,10,6,8,7,9,56,2,0,8]
Left "Division by zero"

How it works: define custom versions for operators with individual error handling, i.e. # for ^ and ! for / (resp. div as it is called in Haskell) and lift the others (+, -, *) via q into the monad. The main function f creates a list of unary function form the numbers (without the first one) and the list of the operators in order, e.g. [+6, -10, #6, !8, ...] and reduces this list by feeding the first number into a chain of >>=.
Edit: @Angs found a bug. Fixing it saved 4 bytes.

Since yours is the only only answer yet, how would you feel about retroactively adding a clause that any exceptions must be caught at some point – I think it would better demonstrate error handling capabilities

Allright, done.

One problem I think, inputs aren't checked to be 13, only outputs.

@Angs: Yes, but luckily it's easy to fix. It even saved 4 bytes. Thanks!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Determine if a relation is transitive
Challenge description
Let's start with some definitions:

a relation is a set of ordered pairs of elements (in this challenge, we'll be using integers)

For instance, [(1, 2), (5, 1), (-9, 12), (0, 0), (3, 2)] is a relation.

a relation is called transitive if for any two pairs of elements (a, b) and (b, c) in this relation, a pair (a, c) is also present,
[(1, 2), (2, 4), (6, 5), (1, 4)] is transitive, because it contains (1, 2) and (2, 4), but (1, 4) as well,
[(7, 8), (9, 10), (15, -5)] is transitive, because there aren't any two pairs
(a, b), (c, d) present such that b = c.
[(5, 9), (9, 54), (0, 0)] is not transitive, because it contains (5, 9) and (9, 54), but not (5, 54)

Given a list of pairs of integers, determine if a relation is transitive or not.
Input / output
You will be given a list of pairs of integers in any reasonable format. Consider a relation
[(1, 6), (9, 1), (6, 5), (0, 0)]
The following formats are equivalent:
[(1, 6), (9, 1), (6, 5), (0, 0)] # list of pairs (2-tuples)
[1, 9, 6, 0], [6, 1, 5, 0] # two lists [x1, x2, ..., xn] [y1, y2, ..., yn]
[[1, 6], [9, 1], [6, 5], [0, 0] # two-dimentional int array
[4, 1, 6, 9, 1, 6, 5, 0, 0] # (n, x1, y1, ..., xn, yn)
[1+6i, 9+i, 6+5i, 0+0i] # list of complex numbers

... many others, whatever best suits golfing purposes

Output: a truthy value for a transitive relation, falsy otherwise. You may assume that the input will consist of at least one pair, and that the pairs are unique.

Does the input have to be a list-like format, or can it be an adjacency--matrix-like format?

You should have a test case that is only transitive because the pairs are ordered. E.g. (1,3) (2,1) (3,4) (1,4) (2,4). If the pairs weren't ordered, this wouldn't be transitive because (2,3) is missing.

@MartinEnder I think you misinterpreted "ordered pairs". I don't think it means the pairs in an order - I think it means each pair has an order, first then second.

@isaacg that's what I meant. In other words, my test case is only truthy because the relation isn't implicitly symmetric.

Should the third test case ([(7, 8), (9, 10), (15, -5)]) be not transitive?

@MartinEnder What I'm saying is it's not transitive - (2, 1) and (1, 3) are present, and (2, 3) is not, so it's not transitive. An example of what you're saying would be (1, 2), (1, 3).

@isaacg oh, completely overlooked that one. You're right, your test case is better.

@wnnmaw: No. The definition is "a relation r is transitive if for any a, b, c in r [(a, b) in r and (b, c) in r] => (a, c) in r. Since the left side of the implication is false, the whole expression evaluates to true.

Can the truthy value depend on the relation? e.g. output the relation for true, output 0 for false?

@ngenisis: sure, those are considered truthy and falsy

Haskell, 42 bytes
f x=and[elem(a,d)x|(a,b)<-x,(c,d)<-x,b==c]

Usage example: f [(1,2), (2,4), (6,5), (1,4)]-> True.
(Outer)loop over all pairs (a,b) and (inner)loop over the same pairs, now called (c,d) and every time when b==c check if (a,d)is also an existent pair. Combine the results with logical and.

Most readable answer so far!

@Lynn Check out the Prolog answer, then ;-)

 Prolog, 66 bytes
t(L):-not((member((A,B),L),member((B,C),L),not(member((A,C),L)))).

The relation is not transitive if we can find (A,B) and (B,C) such that (A,C) doesn't hold.

MATL, 27 25 bytes
7#u2e!l6MX>thl4$XQttY*g<~

Input format is a matrix (using ; as row separator) where each pair of the relation is a column. For example, test cases
[(1, 2), (2, 4), (6, 5), (1, 4)]
[(7, 8), (9, 10), (15, -5)]
[(5, 9), (9, 54), (0, 0)]

are respectively input as
[1 2 6 1; 2 4 5 4]
[7 9 15; 8 10 -5]
[5 9 0; 9 54 0]

Truthy output is a matrix formed by ones. Falsy is a matrix that contains at least one zero.
Try it online!
Explanation
The code first reduces the input integers to unique, 1-based integer values. From those values it generates the adjacency matrix; matrix-multiplies it by itself; and converts nonzero values in the result matrix to ones. Finally, it checks that no entry in the latter matrix exceeds that in the adjacency matrix.

JavaScript (ES6), 69 67 bytes
a=>(g=f=>a.every(f))(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))

Saved 2 bytes thanks to an idea by @Cyoce. There were four previous 69-byte formulations:
a=>a.every(([b,c])=>a.every(([d,e])=>c-d|a.some(([d,c])=>b==d&c==e)))
a=>!a.some(([b,c])=>!a.some(([d,e])=>c==d&a.every(([d,c])=>b-d|c-e)))
a=>a.every(([b,c])=>a.every(([d,e])=>c-d|!a.every(([d,c])=>b-d|c-e)))
(a,g=f=>a.every(f))=>g(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))

You might be able to shorten the second solution by making an abbreviation for .every

@Cyoce Indeed, you save 3 bytes each time by writing [e], so even though it costs 8 bytes to assign e you still save a byte. However, I went a step further by making an abbreviation for a.every, which saved a second byte.

Pyth, 14 bytes
!-eMfqFhTCM*_M

Test suite
Input format is expected to be [[0, 0], [0, 1], ... ]
!-eMfqFhTCM*_M
!-eMfqFhTCM*_MQQQ    Variable introduction
            _MQ      Reverse all of the pairs
           *   Q     Cartesian product with all of the pairs
         CM          Transpose. We now have [[A2, B1], [A1, B2]] for each pair
                     [A1, A2], [B1, B2] in the input.
    f                Filter on
       hT            The first element (the middle two values)
     qF              Being equal
  eM                 Take the end of all remaining elements (other two values)
 -              Q    Remove the pairs that are in the input
!                    Negate. True if no transitive pairs were not in the input

Brachylog, 24 bytes
'{psc[A:B:B:C],?'e[A:C]}

Try it online!
Explanation:
'{psc[A:B:B:C],?'e[A:C]}
'{                     } it is impossible to find
    c                    a flattened
   s                     subset of
  p                      a permutation of the input
     [A:B:B:C]           that has four elements, with the second and third equal
              ,?         and such that the input
                'e       does not contain
                  [A:C]  a list formed of the first and fourth element

In other words, if the input contains pairs [A:B] and  [B:C], we can permute the input to put [A:B] and  [B:C] at the start, delete all other elements, and produce a list [A:B:B:C]. Then we return truthy from the inner predicate (falsey from the whole program) if [A:C] isn't there.

CJam (22 bytes)
{__Wf%m*{z~~=*}%\-e_!}

Online test suite. This is an anonymous block (function) which takes the elements as a two-level array, but the test suite does string manipulation to put the input into a suitable format first.
Dissection
{         e# Begin a block
  _       e#   Duplicate the argument
  _Wf%    e#   Duplicate again and reverse each pair in this copy
  m*      e#   Cartesian product
  {       e#   Map over arrays of the form [[a b][d c]] where [a b] and [c d]
          e#   are in the relation
    z~~=* e#     b==c ? [a d] : []
  }%
  \-      e#   Remove those transitive pairs which were in the original relation
  e_!     e#   Test that we're only left with empty arrays
}

Mathematica, 49 bytes
#/.{x=___,{a_,b_},x,{b_,c_},x}/;#~FreeQ~{a,c}:>0&

Pure function which takes a list of pairs. If the input list contains {a,b} and {b,c} but not {a,c} for some a, b, c, replaces it with 0. Truthy is the input list, falsy is 0.

C++14, 140 bytes
As unnamed lambda returning via reference parameter. Requires its input to be a container of pair<int,int>. Taking the boring O(n^3) approach.
[](auto m,int&r){r=1;for(auto a:m)for(auto b:m)if (a.second==b.first){int i=0;for(auto c:m)i+=a.first==c.first&&b.second==c.second;r*=i>0;}}

Ungolfed and usage:
#include<vector>
#include<iostream>

auto f=
[](auto m,int&r){
  r=1;                         //set return flag to true
  for(auto a:m)                //for each element
    for(auto b:m)              //check with second element
      if (a.second==b.first){  //do they chain?
        int i=0;               //flag for local transitivity
        for(auto c:m)          //search for a third element
          i+=a.first==c.first&&b.second==c.second;
        r*=i>0;                //multiply with flag>0, resulting in 0 forever if one was not found
      }
}
;

int main(){
 std::vector<std::pair<int,int>> m={
  {1, 2}, {2, 4}, {6, 5}, {1, 4}
 };

 int r;
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,6);
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,5);
 f(m,r);
 std::cout << r << std::endl;

}

Python 2, 91 67 55 bytes
lambda s:all(b-c or(a,d)in s for a,b in s for c,d in s)

Try it online!
-24 bytes thanks to Leaky Nun
-12 bytes thanks to Bubbler

67 bytes (and fixed your code by changing lambda x to lambda s.

@LeakyNun Oh whoops, that was supid stupid of me. Thanks!

55 bytes by unpacking at fors.

05AB1E, 14 bytes
íâ€øʒθË}€нIKg_

Port of @isaacg's Pyth answer, so make sure to upvote him/her as well!
Also takes the input as a list of pairs (e.g. [[1,2],[3,4],...]).
Try it online or verify all test cases.
Explanation:
í           # Reverse each pair of the (implicit) input-list
 â          # Get the cartesian product of this list and the (implicit) input-list,
            # creating pairs of pairs
  €         # Map over each pair of pairs:
   ø        #  Zip/transpose; swapping rows/columns
            # (we now have a list of [[x1,y2],[y1,x2]] of each pair in the input-list,
            # including those where [x1,y1]==[x2,y2])
    ʒ       # Filter this list of 2x2 blocks by:
     θ      #  Get the last row: [y1,x2]
      Ë     #  Check if the values in the pair are the same: y1==x2
    }€      # After the filter: map over each remaining 2x2 block:
      н     #  Leave just the first row: [x1,y2]
       IK   # Remove all input-pairs from this list of remaining pairs
         g  # And then check if the length
          _ # is equal to 0 (1 if the list was empty; 0 if not)
            # (after which the result is output implicitly)

Axiom 103 bytes
c(x)==(for i in x repeat for j in x repeat if i.2=j.1 and ~member?([i.1, j.2],x)then return false;true)

ungolfed:
c(x)==
  for i in x repeat
    for j in x repeat
       if i.2=j.1 and ~member?([i.1, j.2],x) then return false
  true

                                                                   Type: Void

the exercises
(2) -> c([[1,2],[2,4],[6,5],[1,4]])
   Compiling function c with type List List PositiveInteger -> Boolean
   (2)  true
                                                                Type: Boolean
(3) -> c([[7,8],[9,10],[15,-5]])
   Compiling function c with type List List Integer -> Boolean
   (3)  true
                                                            Type: Boolean
(4) -> c([[5,9],[9,54],[0,0]])
   Compiling function c with type List List NonNegativeInteger ->
      Boolean
   (4)  false

Pyth - 22 21 bytes
.Am},hdedQfqFtPTsM^Q2

Test Suite.

Clojure, 56 53 bytes
Update: Instead of using :when I'll just check that for all pairs of [a b] [c d] either b != c or [a d] is found from the input set.
#(every? not(for[[a b]%[c d]%](=[b nil][c(%[a d])])))

Original:
Wow, Clojure for loops are cool :D This checks that the for loop does not generate a falsy value, which occurs if [a d] is not found from the input set.
#(not(some not(for[[a b]%[c d]% :when(= b c)](%[a d]))))

This input has to be a set of two-element vectors:
(f (set [[1, 2], [2, 4], [6, 5], [1, 4]]))
(f (set [[7, 8], [9, 10], [15, -5]]))
(f (set [[5, 9], [9, 54], [0, 0]]))

If input must be list-like then (%[a d]) has to be replaced by ((set %)[a d]) for extra 6 bytes.

Both these solutions are unnamed functions taking a list of ordered pairs as input and returning True or False.
Mathematica, 65 bytes
SubsetQ[#,If[#2==#3,{#,#4},Nothing]&@@@Join@@@#~Permutations~{2}]&

#~Permutations~{2}] creates the list of all ordered pairs of ordered pairs from the input, and Join@@@ converts those to ordered quadruples. Those are then operated upon by the function If[#2==#3,{#,#4},Nothing]&@@@, which has a cool property: if the middle two elements are equal, it returns the ordered pair consisting of the first and last numbers; otherwise it returns Nothing, a special Mathematica token that automatically disappears from lists. So the result is the set of ordered pairs that needs to be in the input for it to be transitive; SubsetQ[#,...] detects that property.
Mathematica, 70 bytes
And@@And@@@Table[Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j},{i,#},{j,#}]&

Table[...,{i,#},{j,#}] creates a 2D array indexed by i and j, which are taken directly from the input (hence are both ordered pairs). The function of those two indices is Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j}, which translates to "either the second element of i and the first element of j don't match, or else the input contains the ordered pair consisting of the first element of i and the last element of j". This creates a 2D array of booleans, which And@@And@@@ flattens into a single boolean.

APL(NARS), 39 chars, 78 bytes
{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}

test:
  f←{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}
  f (1 2) (2 4) (6 5) (1 4)
1
  f (7 8) (9 10) (15 ¯5)
1
  f (5 9) (9 54) (0 0)
0

one second 'solution' follow goto ways:
r←q w;i;j;t;v
r←1⋄i←0⋄k←↑⍴w⋄→3
r←0⋄→0
→0×⍳k<i+←1⋄t←i⊃w⋄j←0
→3×⍳k<j+←1⋄v←j⊃w⋄→4×⍳t[2]≠v[1]⋄→2×⍳∼(⊂t[1]v[2])∊w

Common Lisp, 121 bytes
(lambda(x)(not(loop for(a b)in x thereis(loop for(c d)in x do(if(= b c)(return(not(member`(,a ,d) x :test #'equal))))))))

Try it online!