[Question]
  [
Gah! It's a shame that Pokémon Sword and Shield won't introduce a new eeveelution. Let's mourn them with a code golf.
The objective is to, when given a type name as the input, output the name of the corresponding eeveelution.
* When given `Water`, output `Vaporeon`.
* When given `Electric`, output `Jolteon`.
* When given `Fire`, output `Flareon`.
* When given `Psychic`, output `Espeon`.
* When given `Dark`, output `Umbreon`.
* When given `Grass`, output `Leafeon`.
* When given `Ice`, output `Glaceon`.
* When given `Fairy`, output `Sylveon`.
* All other input falls in *don't care* situation.
No other rules. Enjoy!
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~77~~ 76 bytes
```
lambda s:'VFULJSGEalmeoylspaballaporrftvc'[hash(s)%3695%8::8]+'reon'[s<'V':]
```
[Try it online!](https://tio.run/##JYpBC4IwGEDP@St2kc/IU1HUyFspRYcgtIN5@FwbjpaTbzPw1xvW6T0erxt8Y9vlqJLHaPBdP5E5DkWaX8637IjmLe1gXIc1GoOdJVL@I6Bs0DWRm4erzW4dbjnfVgsgaVso3R4K4NWYJyXc0UuCmMHRSOFJi8lTTXLi1Q2i@acD0mtiRujcJCfxW1LUNEAVKEusZ7plOQ9mHenWsz5mKurn4xc "Python 2 – Try It Online")
In Python 2, the `hash` function consistently (across runs and also on different platforms) converts any immutable value into a 64-bit integer. By taking that integer first mod `3695`, then mod `8`, we get an integer `0<=i<8` (`3695` was found by brute force checking all possible values upto `10000`).
A common trick is used to encode a list of same-size strings into a single string and then using slicing via `[i::8]`to extract the strings without using `.split` or similar strategy. Only two options are not of length 4: `Esp` and `Vapor`. The former is handled by making it the last of the 8 strings encoded; and `Vapor` is handled using the final slicing `'reon'[s<'V':]`.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~72 67 65~~ 64 bytes
```
{<Sylv Esp Glac Jolt Leaf Umbr Flar Vapor>[:36($_)%537%8]~'eon'}
```
[Try it online!](https://tio.run/##TZBPS8NAEMXP7qcYsH@SoiESbIu1OdkWiwehVA8llG26weC2G2ZWZQnpV4@7aw4efzOPmfdeJVCO25OBQQFzaOvHjZHfsKAKVpLnsFZSw4vgBWxPB4Sl5AhvvFKY7h6ScdDbh/37ZNKfZpehUOdh014TNyDLs6CIFOqgdrLoR@GRdnHWqZswTbvZaHaXWaCvA2kM4pvRbRLOGCsUQuDP/JfGGdTsyn3o7WGeQjQoWNO@cy06V9YDW0iRayz/vLvBskThnTt4JZN/2KVN6PCJ46eP5mCFnMindfScC9@BP8FLNOCqsfQL "Perl 6 – Try It Online")
A golf to all unique indexes by parsing the string as base 36 and moduloing it. I've left a version that just uses the sum below so other answer that may not have the same short base converting code that Perl 6/Raku does. There is also base 35 with modulo 51 and 10, but that comes out to the same byte count.
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 67 bytes
```
{<Leaf Esp Umbr Vapor 0 Sylv Flar Jolt Glac>[.ords.sum%64%9]~'eon'}
```
[Try it online!](https://tio.run/##LY@7CsJAEEVr8xVTGF9FsJCAaFKZiGIhiFqEIOO6weDmwWxUlqC/HncXyzOve6bmJPyuUDDIIICuXe44ZhDJGo7FleCEdUUwhYMSL4gFEmwr0cBaIAsTr6Kb9OSzcP2ZO0@/Q16Vw0@X6Y2RyEsux2Hovc1QMllMU2idnkQF/QsEIXiDzPl0Z2z4P0UvO5HgrKGc2RRTiHPiNtfAXip2101tZ3CF9LCWBtaEUoKRN7Rh3DraE5iTsg9o@gE "Perl 6 – Try It Online")
Differentiates between inputs by the sum of the ordinal values, modulo 64 modulo 9, leaving one extra spot to be filled in. Unfortunately, my [brute force script](https://tio.run/##PZBPa4NAFMTP7qd4B3VbSBeTQ0iJSg5NQksPhdA/EFJ4a1cqXaPs2hYR@9XNPoXuZZnHbwZmamX0cihbCHNIYOji@KHSDTwqzGGvMYOtreEF68pw/lxKA4dW/3D3dhpNmh5FZT6ssN9lsIiC@fz0x1V15j0lbtAl6uKsbJqKsBO/hB6j07@lXzOWVwYWkRDLKIKbFHyEjnlkls68uXIZb4G7Xq@ZR@hKiHfHECmJJNTPJ1SOqCTUs@juOOPAZ76cvhyK3LHioBpIElhBGJJErSGGW2fqWc@GV2yUmQq7ImyrVdaYIgNahQ67wiig7iSebJt9FuNGJO/QfAGNRGJv0NpxR1L3mRrnHCOwMO24o1MX) couldn't find any pairs of moduli that led to no empty spaces, and adding a third would cost more than it gained.
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-p`, ~~89~~ 67 bytes
Direct port of [Jo King's Perl answer](https://codegolf.stackexchange.com/a/195464/52194). ~~By sheer coincidence, the byte count is even the same.~~ The byte counts are no longer the same as Jo King has switched to using a technique that cannot be tersely replicated in Ruby.
```
$_=%w"Leaf Esp Umbr Vapor 0 Sylv Flar Jolt Glac"[$_.sum%64%9]+'eon'
```
[Try it online!](https://tio.run/##Dcy7CsIwFADQPV9xKQ0dio9BBIdutkVxEEQdRMptiDSYNOEmVfLzxo5nOTT1MYnBGpfyruLf7CTxBbV3cDU9wQ2dJVjDJeoPNBoJjlYHaDWK7JF3Sz8Zvt3w3bMspB2L@YCygnyV7hgksVpLEUgJ1iiS7OyjGGbskd6sJfSeHYRkDSqKP@uCsqNPC/cH "Ruby – Try It Online")
### Original Version, Ruby `-p`, 89 bytes
Basic lookup checking the first letter of the input (or first 2 if the second letter is `i`, which is only present in `Fire`).
```
$_=%w"WVapor EJolt PEsp DUmbr GLeaf IGlac FSylv FiFlar".find{|e|e.sub!$_[/.i?/],''}+'eon'
```
[Try it online!](https://tio.run/##DczBCoIwGADg@57iT4wdLH0C6aITo4MQ5SFC5po0Wk7@zWJkr555/C4fjq2f57BJ1@@gPvPBIOR7ox1UuR0gOz1bhOIgeQdlobkAdvT6BUwxzTGIO9XfPpOcZGzHdhU2lyRWu@S6ofQbUWl6uswQpRAmc82dRJJrKRwqQZhCSSrrxX1BxvFBCuTWklJIwrhC/zODU6a383b4Aw "Ruby – Try It Online")
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 29 bytes
```
EF 73 77 59 25 54 25 75 09 60 84 58 22 23 61 82 73 82 72 00 24 52 40 7E 5F 39 39 73 EF
```
[Try it here!](https://pyke.catbus.co.uk/?code=EF+73+77+59+25+54+25+75+09+60+84+58+22+23+61+82+73+82+72+00+24+52+40+7E+5F+39+39+73+EF&input=Fairy&warnings=0&hex=1), [Ungolfed with full tests](https://pyke.catbus.co.uk/?code=F.os+57%25T%25+96+600+34+35+97+371+370+0+36%5D9R%40%7E_99s.o&input=%5B%22Water%22%2C+%22Electric%22%2C+%22Fire%22%2C+%22Psychic%22%2C+%22Dark%22%2C+%22Grass%22%2C+%22Ice%22%2C+%22Fairy%22%5D&warnings=0&hex=0)
```
.o                                           -      map(ord, input)
  s                                          -     sum(^)
   wY%T%                                     -    (^ % 57) % 10     // wY is 57
                                   R@        -    v[^]
        u\t`\x84X"#a\x82s\x82r\x00$          -   [96, 600, 34, 35, 97, 371, 370, 0, 36]
                                     ~_99s   -  ^ + 333333 + 99
                                          .o - dictionary_lookup(^)
```
We start off by converting the input to a list of integers corresponding to the ascii characters and then summing them. This produces the following set of numbers for `["Water", "Electric", "Fire", "Psychic", "Dark", "Grass", "Ice", "Fairy"]`: `[515, 811, 390, 723, 386, 512, 273, 507]`. We then perform a magic operation (`(x % 57) % 10`) to get the following list of offsets: `[2, 3, 8, 9, 4, 6, 5, 1]`.
The bytes below correspond to the following compressed list: `[96, 600, 34, 35, 97, 371, 370, 0, 36]`, and we index into it based on the offsets we had previously. There's a 0 in there due to my inability to get it not to wrap.
```
75 09 60 84 58 22 23 61 82 73 82 72 00 24
```
[Try it here!](https://pyke.catbus.co.uk/?code=75+09+60+84+58+22+23+61+82+73+82+72+00+24&input=&warnings=0&hex=1)
This list of numbers corresponds to the location in the Pokedex, minus 100. Pyke's dictionary handily contains the Pokedex starting from index 333333 (0 indexed). It also comes with a convenient default variable, `~_`, for getting that particular number. We then add 99 to it to take an offset to Pyke's dictionary, and then use `.o` to look up that particular word.
[Answer]
# [ink](https://github.com/inkle/ink), ~~111~~ 110 bytes
```
=e(t)
{
-t?"W":Vapor
-t?"E":Jolt
-t?"P":Esp
-t?"y":Sylv
-t?"D":Umbr
-t?"G":Leaf
-t?"I":Glac
-1:Flar
}<>eon->->
```
[Try it online!](https://tio.run/##VY4xD4IwFIT3/gryJhg6uDZYF5BgHEiMsrDUpsaGCqRtTIjxtyNUa8p2d9@9vJNdO9XMCh01mKY0wlTE4AJIMEVNhHIluNWShwWf@c5eahHyxXtWmZHf1@e/yDcyptsQL96zQjNjQugCT0u@ejvb/yIm9biatAQLnbYitgl6IWx3UAO5sKHXzuRADr2yTldAcjM4OQI5jerpdAbk/Lh@6wWQo2A3p0sghWIc4Q3ZK6bRO6Wi7zCd300f "ink – Try It Online")
## Explanation
```
=e(t)          // Define a stitch e which takes a parameter t
{              // An if block - finds the first condition that is true and doeses the associated thing
-t?"W":Vapor   // If "W" is a substring of our parameter, we print "Vapor"
-t?"E":Jolt    // otherwise, if "E" is a substring of our parameter, we print "Jolt"
-t?"P":Esp     // "P" is for "Psychic"
-t?"y":Sylv    // We can't check "F" for "Fairy" because that'd also match "Fire", but since we got past "Psychic", "Fairy" is the only option that contains "y"
/* et cetera */
-1:Flar        // If we get here, we check if 1 is truthy (it is) and if so, we print "Flar"
}<>eon->->     // Append "eon" to the last line printed, and return.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~47~~ ~~40~~ 38 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.•‡ιÏSnÛ@¥I´4óÈ¬–[и)h‘j"õújв•#ć«™sÇ<Oè
```
-7 bytes by porting [*@JoKing*'s `ord-sum % 64` trick](https://codegolf.stackexchange.com/a/195464/52210).  
-2 bytes thanks to [*@JonathanAllan* by using the `ord-sum - length`](https://codegolf.stackexchange.com/a/195533/52210) on the input-type instead.
[Try it online](https://tio.run/##AVMArP9vc2FiaWX//y7igKLigKHOucOPU27Dm0DCpUnCtDTDs8OIwqzigJNb0LgpaOKAmGoiw7XDumrQsuKAoiPEh8Kr4oSic8OHPE/DqP//UHN5Y2hpYw) or [verify all test cases](https://tio.run/##yy9OTMpM/V9W6WKvpPCobZKCkv1/vUcNix41LDy383B/cN7h2Q6Hlnoe2mJyePPhjkNrHjVMjr6wQzPjUcOMLKXDWw/vyrqwCahc@Uj7odWPWhYVH2638T@84r/O/2il8MSS1CIlHSXXnNTkkqLMZCDTLbMoFUgFFFcmZ4AFXBKLsoGUe1FicTGQ9kwGSbslZhZVKsUCAA).
**Explanation:**
```
.•‡ιÏSnÛ@¥I´4óÈ¬–[и)h‘j"õújв•
            "# Push compressed string "eon glac  jolt leaf umbr esp vapor sylv flar"
  #          # Split it on spaces:
             #  ["eon","glac","","jolt","leaf","umbr","esp","vapor","sylv","flar"]
   ć         # Extract head; pop and push remainder-list and the first item
    «        # Concat this first item "eon" to each string in the remainder-list
     ™       # Titlecase each Eeveelution
      sÇ     # Get the input, and convert it to a list of unicode values
        <    # Decrease each value by 1
         O   # Sum these integers
          è  # And use this to (0-based) index into the list (with automatic wrap-around)
             # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•‡ιÏSnÛ@¥I´4óÈ¬–[и)h‘j"õújв•` is `"eon glac jolt leaf umbr esp vapor sylv flar"`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 50 bytes
```
§⪪”↶2'⧴mＢ⁼“↷⁻o⊟ＨtωhJ№↘Tθ⁼σ4Þχ℅)Zh” ⌕rtFhDscy§Ｓ⁴eon
```
[Try it online!](https://tio.run/##NY2xCsIwFEV3v@LxpgTq5tZJ0EjEQQi6xzTawGsS0mexXx8D4hkvh3vcaItLlmq9lhBZ7FnHwX@EyRRY4N3mVOCciEGRLXCcM9ymR4GLt084kXVgVlqwAwSUHagQB4GF1XiY3drm/5@O@c2GW@MlmreTjX7za6JPEWVfq3a@bhf6Ag "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
§⪪”↶2'⧴mＢ⁼“↷⁻o⊟ＨtωhJ№↘Tθ⁼σ4Þχ℅)Zh” 
```
Split the compressed string `Vapor Jolt Flar Esp Umbr Leaf Glac Sylv` on spaces and index into it using...
```
⌕rtFhDscy§Ｓ⁴
```
... the index of the fourth character of the input (taken cyclically) in the string `rtFhDcsy`.
```
eon
```
Output the shared suffix.
[Answer]
# Java 8, 84 bytes
```
t->"Leaf Esp Umbr Vapor  Sylv Flar Jolt Glac".split(" ")[t.chars().sum()%64%9]+"eon"
```
Port of [*@JoKing*'s Perl answer](https://codegolf.stackexchange.com/a/195464/52210).
[Try it online.](https://tio.run/##PZBBTsMwEEX3PcXIUqVYoV4hJKhgRVOBoEJCwKLqYuo61K1jR7YTFFXZcgCOyEXCJAQ2/uNva96fOWCNs8Pu2EmDIcAjanuaAGgblc9RKlj1V4Dn6LV9B5WMReRz8tsJHSFi1BJWYOG6i7Mb9qAwh0Uo4aXYenjF0nlq0JgaMoMe7p2JsDQomQil0TFhwPg6CrlHHxIuQlUkfHpxPr3cpEw5y7p5jymrrSHMSKud3kFBacdA6w0g/42aO/@fsikVXIFVH/D37cTekGZjZ2xhlCRTUplpr0ieQiP3g3GL/kiy9LQU0jvZP2eofcNaPlD6iUJUhXBVFCX1jsYmPS9l8P35BSy1Qg0GH1fVdj8)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 43 bytes
```
“ȦF³ḢẎŻṣ>[ɲ$Ɱ'⁻⁹ḋm¿:ṪœeḂɲẆy$\»Ḳ;€“°9»ŻɓO’Sị
```
**[Try it online!](https://tio.run/##AWgAl/9qZWxsef//4oCcyKZGwrPhuKLhuo7Fu@G5oz5bybIk4rGuJ@KBu@KBueG4i23CvzrhuarFk2XhuILJsuG6hnkkXMK74biyO@KCrOKAnMKwOcK7xbvJk0/igJlT4buL////J1dhdGVyJw "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##y0rNyan8//9Rw5wTy9wObX64Y9HDXX1Hdz/cudgu@uQmlUcb16k/atz9qHHnwx3duYf2Wz3cuero5NSHO5pObnq4q61SJebQ7oc7Nlk/aloDNOLQBstDu4/uPjnZ/1HDzOCHu7v/H91zuB0o5/7/f7R6eGJJapG6joK6a05qcklRZjKI7ZZZlAqiA4orkzMgQi6JRdkg2r0osbgYxPBMBitxS8wsqlSPBQA "Jelly – Try It Online").
### How?
First makes the list `['Jolt', 'Leaf', 'Umbr', 'Esp', 'Vapor', 'Sylv', 'Flar', 'Glac']`, adds `'eon'` to each, and prepends a zero to the list. Then gets the ASCII code-points of the characters in the input list, subtracts one from each, sums those up and indexes into the created list (using 1-based, modular indexing - i.e. gets the value at index `i%9`). 
[Answer]
# [Julia 1.0](http://julialang.org/), ~~85~~ ~~83~~ 75 bytes
```
f(s)=strip("VUEJGSFLamsolylepbplalaaor tcvrfr"[6hash(s)%47%8+1:8:33])*"eon"
```
[Try it online!](https://tio.run/##Vc09C8IwFIXh3V9RAoVGp1LRUhAcbIviIIg6iMM1JCQaTbm3fvTXx06SjueBw3t7WQPp13uVEF9Qi6ZJ2PFQbup9tYUHOdtZ2VwbCxbAYdSKNypk55kG0v0lns7jfJIWeZFlFz5m0j2ZX5J2n0glrDIoGR/99wlaiSGUVoq@KULbUSf0kFaA93DXCEQhrMWgU4HBjnH/Aw "Julia 1.0 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p -MList::Util=pairfirst`, 84 bytes
```
$_=(pairfirst{/$a/}D,Umbr,E,Jolt,Fa,Sylv,Fi,Flar,G,Leaf,I,Glac,P,Esp,W,Vapor)[1].eon
```
[Try it online!](https://tio.run/##Pc6xCsIwEADQPd/RQeFqcXApdGsTKhUKUh1E5AwpHsYmXIJQxF83OvkF73nDdpNSdqkWHolH4hBfRYbFu4bhcWVoYOtsBImwn@0TJIG0yKCgMzhCC8qihh6a4OEIB/SOl6f1eWXclFIfZn0jLSSxETXyXSjGEESrjZA/bf44H8lNIeW7jkIsyyGSrf6RlHv7BQ "Perl 5 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 103 bytes
I hash the first four bytes of the string to determine the index into the array (the hash function is not optimal, but works well enough: there's probably a more efficient one, but it would likely be bigger!) After the index is computed, I then print the four (or five) characters of the prefix and end with "eon". It's more compact than a string array, and by keeping the five-character string at the end I simplify the indexing.
I used some quirks in the language and implementation to save some length:
* Due to operator precedence, I use `4|j>7` to give me 4 or 5, as bitwise operators have a lower precedence than relational ones.
* Strings have to have `int`-appropriate alignment and `int` has to be a 32-bit, little-endian value so I can use type punning on the input string; fortunately this is the case for the test environment.
```
j;f(int*i){(j=(*i-2)%12%10)&&j--;printf("%.*seon",4|j>7,"SylvEsp\0JoltFlarLeafUmbrGlac    Vapor"+4*j);}
```
[Try it online!](https://tio.run/##PY9Bb8IwDIXv/RVWJlASWgQIaYesnEbRJjRNQmyHbYcspDRdaKs4MFWsf31d4DAf3mf5SX62SvZK9X0pcmoqzw070zKl3CQzNpjOBtMJGw7LJBGNC3ZOyWDMUdcViec/5eI2JpvWnpbYvE8ea@szK91ay3x7@HQrKxWEepFN7chozksmuv7GVMoedxru0O9MPS4WURQWw0Gaip5qs2NwjgBUIR1w3zYa3z7SM3mVXjsSk6XVyjujQpsZpwOesVXFdXAv3VfAyknEwAd1sTNpXEvip@163cXAuQ@CIgoRee2oT68RAjDlfjQS0Bw9UkJYuAL@P0ZIF0BiQCYgpxftoq7/VbmVe@yT7z8 "C (gcc) – Try It Online")
]