[Question]
  [
*Randomly inspired by [Numbers Increase While Letters Decrease](https://codegolf.stackexchange.com/q/138200/42963)*
Given a list of mixed letters and integers (e.g., `['a', 2, 3, 'b']`) *increase* the letters by one position in the alphabet (wrapping at `z` to `a`) and *decrease* the numbers by 1. For the above example, the output should be `['b', 1, 2, 'c']`.
* The input can be a mixed-type list, a delimited string, a list of strings, etc.
* `z` wraps to `a`, but `1` goes to `0`, and `0` goes to `-1`, etc.
* The input will only ever be `[a-z]` and integers. You can choose capital letters `[A-Z]` as input if that's easier for you.
* The input is guaranteed non-empty.
* The input may contain only numbers or only letters.
Examples:
```
Input
Output
['a', 2, 3, 'b']
['b', 1, 2, 'c']
['a', 'b', 'z']
['b', 'c', 'a']
[-1, 0, 257, 'x']
[-2, -1, 256, 'y']
[0, 3, 1, 20382876]
[-1, 2, 0, 20382875]
```
### Rules and Clarifications
* Input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* You can print the result to STDOUT or return it as a function result.
* The output doesn't have to be the same format as the input (e.g., you could take input as a string and output as a list).
* Either a full program or a function are acceptable.
* If applicable, you can assume the input/output integers fit in your language's native `int` range.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
<AAÀ‡
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fxtHxcMOjhoX//0crVSnpKBjqKBjpKCglK8UCAA "05AB1E – Try It Online")
```
<          # decrement the numbers
 A         # constant "abcdefghijklmnopqrstuvwxyz"
  AÀ       # same, but rotated left ("bcd...yza")
    ‡      # transliterate
```
[Answer]
# [Python 3](https://docs.python.org/3/), 59 bytes
```
lambda a:[i-1if''!=i*0else chr(97+(ord(i)+8)%26)for i in a]
```
[Try it online!](https://tio.run/##VY7LCoMwEEX3fsUUKZNUBY34aMEvSV3EFwasinVR@/PpqHXhLMIw595DxmVuhz40TfY0nXoVlQL1kNoLdIN4yfTNr7t3DWU7sXvisGGqmOZOyq8i5s0wgQbdg8rNOOl@Zg2TqNAF4ULoAhaYcw40tqTdhWAjWGJuWefChvF75I8CRelRp7xHFp9EUULo82/Y0iPzikQU0305VfztOyv0w1SkSbyW7M0kdtl@j3LzAw "Python 3 – Try It Online")
*-1 byte thanks to Erik the Outgolfer*
[Answer]
# [Perl 5](https://www.perl.org/) (-p), 17 bytes
```
y/a-z/b-za/or$_--
```
[Try it online!](https://tio.run/##K0gtyjH9/79SP1G3Sj9JtypRP79IJV5X9///Ki4TIy5dI67kf/kFJZn5ecX/dQtyAA "Perl 5 – Try It Online")
Bonus 19-byter:
```
$_>$_++?$_-=2:s/a//
```
[TIO](https://tio.run/##K0gtyjH9/18l3k4lXlvbXiVe19bIqlg/UV////8qLhMjLl0jruR/@QUlmfl5xf91C3IA). This one features some cool tricks, but fails to beat the straightforward solution above.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 34 bytes
For each element, attempt to return the element -1. Strings cannot do this, so they error out and are picked up by the `rescue` clause, which instead calls `succ` on it to return the next letter in the alphabet. `succ` "rolls over" on `z` and returns `aa` though, so we simply take the first character in the returned string.
```
->a{a.map{|e|e-1rescue e.succ[0]}}
```
[Try it online!](https://tio.run/##FcWxCoAgEADQX7nNRaXItX5EHE45WwpEMyj1282W92K2T/drFxsWlCeGUqmSmCMllwlIpuycnkxrPYDXdOMBO13JdM2QcWD25x2ImcM0UhwWZT4 "Ruby – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 55 bytes
```
a=>a.map(s=>1/s?s-1:B([(B(s)[0]+8)%26+97])+'',B=Buffer)
```
[Try it online!](https://tio.run/##bc5LDoIwEAbgvafoxkwbChQID03AhGuQLipSo0EgVI16eRzwtcBZNJn8803nqK7KlP2hO9tNu6sGnQ4qzZRzUh01aea5ZmNsb53TgubUsEJIK2FLP7JWsWQWAM/T/KJ11bOhbBvT1pVTt3uqaQEKOPE5CTiBLUjGCJbrkgI7TrwpgxLk4p@bZuDxYT@HAh81ZzZuFLg0jDG/veHIbPxnDP0wwuQ@l2K6cZwQQeIncTTaSb6OFN8klMMT "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 182 130 118 bytes
*-51 bytes thanks to @AdmBorkBork and @Black Owl Kai, -1 byte thanks to @Black Owl Kai, -12 bytes by replacing `.append()` with `+=[]` and replacing `n+1` with `-~n`*
```
def a(x):
 b='abcdefghijklmnopqrstuvwxyz';c=[]
 for d in x:
  try:c+=[d-1]
  except:c+=[b[(-~b.find(d)%26)]]
 return c
```
[Try it online!](https://tio.run/##Vcw7DoMwEATQnlNsE9lWIOKjACLiJIgC2xCcjyGOSQxFrk5WdDRbzJvZcbb9oJN1lW0HDXWs8ICXpOECg2uvbvfHUw/jy7zt9Pm6eSEXUVa1B91gQILS4HAB1syFOJaVDCI0aJ1oR7slvKLBj586pSWV7BCnrMaGae1kNIh1NEpb2tCKNMSH2IfEB8JJzZi3JwzxLHsJIh9CnJ0zNLe3cPuFhThM8jjPUtT1Dw "Python 3 – Try It Online")
I made this while the question was in the Sandbox but didn't see it posted until just now. :P
## Ungolfed
```
def a(x):
    b = 'abcdefghijklmnopqrstuvwxyz'
    c = []
    for d in x:
        try:
            c.append(d - 1)
        except:
            c.append(b[((b.find(d) + 1) % 26)])
    return c
```
## Explanation
For each element in the inputted list `x`, it tries to subtract 1 and add it to the eventual returned list. If an error occurs (because the element is a string), the letter's index in the alphabet is added by 1 and that mod 26 is taken. The mod 26 wraps an index of 26 back to 0.
[Answer]
# [J](http://jsoftware.com/), 30 bytes
```
<: ::((26|>:)&.(_97+a.i.]))&.>
```
[Try it online!](https://tio.run/##XY67CsJAEEX7fMXFwklws2wm5OGOplCwEgtbWUIUg9rYqvjv6wpGxGKKczhc5uJHmnrMLQgKBjZcqrHcrld@ZmFtHHP5bGwy1nE7rSadPmuXBGp8Eh0Ppyt6UEdCe/pFlvxfBRR6fFWbiREuKqEbYbPQ2KWskGYKXJQKdCc3pCaMZQI2ec11VX7qdxk@VoMvXORf "J – Try It Online")
[Answer]
# [Gema](http://gema.sourceforge.net/), 55 characters
```
<N>=@sub{$1;1}
z=a
<L>=@int-char{@add{@char-int{$1};1}}
```
Dirty solution. Wrapping around on letter increment is painfully long, so got a separate rule.
Input can be quite anything, just use some separators. (You can even omit separators between numbers and letters. With the price of 1 character for changing to `<L1>` you could omit separators between letters too.)
Sample run:
```
bash-5.0$ gema '<N>=@sub{$1;1};z=a;<L>=@int-char{@add{@char-int{$1};1}}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']
```
[Try it online!](https://tio.run/##S0/NTfz/38bPztahuDSpWsXQ2rCWq8o2kcvGByiUmVeim5yRWFTtkJiSUu0AYuoCxYDKaoHqav//j1ZPVNdRMNJRMNZRUE9Sj@WCCACZQKIKxNc11FEwACoxNQeKVIBEDMCqgcJGBsYWRhbmZrEA "Gema – Try It Online")
### Gema, 66 characters
```
<N>=@sub{$1;1}
<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}
```
Clean solution. Half relatively efficient, then half pure pain.
Sample run:
```
bash-5.0$ gema '<N>=@sub{$1;1};<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']
```
[Try it online!](https://tio.run/##S0/NTfz/38bPztahuDSpWsXQ2rCWy8YHyE3OLcgE8ausHTLzSnSTMxKLqh0SU1KqHUBMXaAYULYWqLzWOtG69v//aPVEdR0FIx0FYx0F9ST1WC6IAJAJJKpAfF1DHQUDoBJTc6BIBUjEAKwaKGxkYGxhZGFuFgsA "Gema – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 77 ~~85~~ bytes
Thanks @Giuseppe for a whooping 8 bytes
```
function(l)Map(function(x)"if"(i<-match(x,L<-c(letters,"a"),0),L[i+1],x-1),l)
```
[Try it online!](https://tio.run/##TYxBCsIwFET3niJkk//xB5IUbRf1BvUE4iKGBgOxShshePkYXEg2A/MeM2vxp@Lfi0vhuUDEs33Bv2bkwXMIo3zY5O6QaRqlgzinNK8bccuRFNJ0CXt9pSw1UsTiIYYtgbCCmCHWERM3gbhreSU1Pg2Wmpiqg0NfRW6E@l1Ua1Q3mKE/IpYv "R – Try It Online")
Takes the input as a list. After a big change by @Giuseppe, this makes use of `Map` to apply a function to the list. It makes use of `match` to test for a character. During the test the extended letter list and index are saved for the return. 
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 14 bytes
```
▄\╧¿ò'z=¿Å'a)(
```
[Try it online!](https://tio.run/##y00syUjPz0n7///RtJaYR1OXH9p/eJN6lS2QalVP1NT4/189UZ3LkAtE6gKpMnUu9Sp1AA "MathGolf – Try It Online")
Takes letter as lowercase.
## Explanation
```
▄\╧              Is the element in the lowercase alphabet?
   ¿ò            If so:
     'z=           Is it equal to z?
        ¿Å         If so:
          'a         Push 'a'
            )      Else: Increment the string
             (   Else: Decrement the number
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language#transliterate-t-and-y), ~~52~~ ~~50~~ ~~48~~ ~~58~~ ~~41~~ 37 bytes
```
T`zl`l
\b0
-
\d+
*
-_*
-$.0
_(_*)
$.1
```
-4 bytes thanks to *@FryAmTheEggman* (and for mentioning I had a bug: `1 → -1` instead of `1 → 0`).  
+10 bytes to fix a bug with `1` and `0`.. Such an annoying edge case which screwed me over for quite a while.. But golfed it to 41 bytes now. (Now I'm curious about the <40 bytes versions *@Neil* and *@CowsQuack* mentioned in the comments.. Thanks *@Neil* for the tip of converting the `0` to `-`, and dealing with the negative values first. Converting those right back from unary to integer helped a lot.)  
Apparently I don't need the boundaries at this point, so -4 bytes.. >.>
I/O is comma-separated.
[Try it online.](https://tio.run/##Fck7CoUwFEXR/oxDwc@J3Bt56AycgKWQD1oIYiGvkEw@arF3s67tv59Bc1lNPs8@Hf7AEgUGy9qigXFvRSdwlWtqFJ3mHGjZMyIwMsEohfY38GZioEJeVFrpRwo@VPn2AA)
**Explanation:**
Transliterate all `"zabcdefghijklmnopqrstuvwxy(z)"` to `"abcdefghijklmnopqrstuvwxyz"`:
```
T`zl`l
```
Replace all standalone `0`s with a `-`:
```
\b0
-
```
Convert all numbers to unary, by replacing them with that amount of underscores:
```
\d+
*
```
For all negative values, with zero or more unary-lines behind it: keep the minus sign, and get the total length of this match (including the `-`), converted back to an integer:
```
-_*
-$.0
```
As for the positive integers: match a positive integer by matching a single unary-line, followed by zero or more unary-lines. And then replace them with the length of that capture group to remove that single unary-line and convert them back to integers simultaneously:
```
_(_*)
$.1
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 103 bytes
```
	U =&UCASE 'A'
N	X =INPUT	:F(END)
	U X @P	:F(D)
	U POS(P) LEN(1) . OUTPUT	:(N)
D	OUTPUT =X - 1	:(N)
END
```
[Try it online!](https://tio.run/##K87LT8rPMfn/nzNUwVYt1Nkx2FVB3VGdy48zQsHW0y8gNITTyk3D1c9FkwuoIkLBIQDEh/AC/IM1AjQVfFz9NAw1FfQU/ENDwOo1/DS5XDghPAXbCAVdBUOIINCY//8duQy5DLicuKIA "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# [PHP](https://php.net/), 50 bytes
```
for(;''<$a=$argv[++$i];)echo$a<a?--$a:(++$a)[0],_;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKzV1W1UEm1VEovSy6K1tVUyY601U5Mz8lUSbRLtdXVVEq00gKKJmtEGsTrx1v///0/8n/S/6r/Bf8P/Rv@NAQ "PHP – Try It Online")
[Tests](https://tio.run/##LU3tCoMwDPzfpyij0IoKzrEPVsUH6Ypko7ODTaXq2Ad7dpeqgQvJ3SXX2nbMita2hLDedH1Hc6qI4sAjniI2iDPX0UKdEZ95jdc4J9623WN/zWyy3HgxTTaH9LDfeUVLQq6NM3CxVCxJ0NFpCuiXUCwGrnpiPjgH7/JhXGWEqof7XUeLUY74Q0jOMwb5ZFdhyG5aBuZiGwYZFHHM4CiQhUAlOirl6F97ma5O9UpOSUPdmV6wWyDJb/wD "PHP – Try It Online")
Outputs letters/integers separated by `_` with a trailing separator.
In PHP you can increment letters directly, so I took advantage of it. But the `z` is incremented to `aa`, to convert it to `a`, the `(++$a)[0]` is used which only outputs the first character of the incremented value.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-m`](https://codegolf.meta.stackexchange.com/a/14339/), ~~13~~ 12 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
-1 byte thanks to Shaggy
```
;¤?UÉ:Cg8+Uc
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW0&code=O6Q/Vck6Q2c4K1Vj&input=Wy0xLCAwLCAyNTcsICJ6Il0)
## Explanation:
```
;o ?UÉ:Cg8+Uc
-m              // Map U through the input:
 o              // Try to create a range [1...U]
   ?            //   If that creates a range (number):
    UÉ          //     Return U-1
      :         //   Else, return:
;      C        //     alphabet (a...z)
        g       //     Index:
         8+Uc   //       8 + char-code of U
```
**Note**: `;` turns `C` into the lowercase alphabet
[Answer]
## Haskell, ~~52~~ 51 bytes
```
map q
q"z"="a"
q x|x>"`"=succ<$>x|1<2=show$read x-1
```
As Haskell doesn't allow lists of mixed types, letters and numbers are taken and returned as strings.
[Try it online!](https://tio.run/##FctBDoIwEEDRPaeYTLq0iSUxbhguoiZMKhVixZZqGAlnt9rN@6s/cLr33mdH5/zgALGKuCIhYxVBNmmxQ0pvaxvVymaamtLwXNTc8xVEm/8zTkAQ5nF6gQIHcEJtcAe4L9SHY4kUPoUVL/lrnedbytqG8AM "Haskell – Try It Online")
Check for every list element: if the string is `"z"`, return `"a"`; if the first character of the string is > `'`'` (i.e. a letter, not a digit), return the successor of the char(s) in the string; else it must be number, so convert to an integer, subtract 1 and turn into a string again.
Edit: -1 byte thanks to @cole.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
®i‘ị®µ’e?€Øa©
```
[Try it online!](https://tio.run/##AT4Awf9qZWxsef//wq5p4oCY4buLwq7CteKAmWU/4oKsw5hhwqn/4bqOw4fFkuG5mP//WydhJywgMiwgMywgJ2InXQ "Jelly – Try It Online")
Clever fix by [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan).
Note: This is not a full program, the footer over TIO makes it possible to input using a command-line argument to test the function.
[Answer]
# [C++17 (gcc)](https://gcc.gnu.org/), 120 bytes
```
#define O int operator()
struct V{O(char&c){c++-90?:c=65;}O(int&i){--i;}};int f(auto&l){for(auto&x:l)std::visit(V{},x);}
```
Here `f` is the required function; `l` is both the input and output parameter, and it is expected to be a container of objects which are compatible with `std::variant<char, int>` or vice versa.
[Try it online!](https://tio.run/##fZJda4MwFIbv/RWHFvygCralH1Pr2KB3g@6qjLEbSbUL2CgxlkLIX193Eru11DEvNDkf73nPg6Sugz0h5yFlpGx3OSTHjNOMifQ83OUFZTlsgDIBVZ3zTFTc9axG8JYI2MqNSz4zbhNPktEoeAgfI7Kaz2K1cbHDpp4MAhorFev@ws1aUdmlJwsUMedTVHqN2EXRkTZUuFup/JMXqxsvJW1Eal3vtMLZeXZIrbahbA/rVdffWU60Gx@HpbF1rOgOao6XF9RwScUaAaZYaybr1IbSA2kBPiZMqlZAksBAwiC@hM2ar1pkqx1WHCQY4SsMQwAISt3JOAP9IZdzDKrXqanQXiPVpapzgKSgQwUniIxhuAF26wzZAcK7M@GDnvzHkgp3VB0kkSOfWzJXMFd@ZU8aglSLFyb1T6HzwRw9S297yChzf8TNXAnOk@PDxIepD86zA8qLe1mM4@u9lwzGPoTYPFtg@q2XDo0o1kzC6XKyXMx/C3guWs4gRF/nL1KU2b45B@h6hb/xePEN "C++ (gcc) – Try It Online")
[Answer]
# dzaima/APL, ~~21~~ 20 bytes
```
{0::⍵-1⋄⎕l(⍳⊇1⌽⊣)⍵}¨
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/qG@qp/@jtgkGXGlAUuN/tYGV1aPerbqGj7pbgHI5Go96Nz/qajd81LP3UddiTaBU7aEV/zW5gHIKQA0KaQrqieoK6knqCkYKxgrqVepIMofWGyoYKBiZmiuoV6j/BwA "APL (dzaima/APL) – Try It Online")
-1 thanks to ngn.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 27 bytes
```
{$[9+@x;`c$97+26!8+x;x-1]}'
```
[Try it online!](https://tio.run/##y9bNz/7/P82qWiXaUtuhwjohWcXSXNvITNFCu8K6Qtcwtlb9f5qGUqKStZGxtVKVkuZ/AA "K (oK) – Try It Online")
-8 thanks to ngn and dzaima :)
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 36 bytes
```
\$ka'~?*3({':+1\
R';$ >i::0Sqn=?/1-$
```
[Try it online!](https://tio.run/##KyrNy0z@/z9GJTtRvc5ey1ijWt1K2zCGK0jdWkXBLtPKyiC4MM/WXt9QV@X//0QFIwVjhSoA "Runic Enchantments – Try It Online")
General process is to read input, prepend with a 0 (coercion to string), convert back to a number (single char will always return -1), compare with input. If same, it must be a numerical value, subtract 1 and print. If not same, it must be a char, subtract 1, compare with `{`. If less than, print, otherwise replace it with `a` and print.
Repeat until program performs a stack underflow.
Output is separated by `;` in order to [save 1 byte](https://tio.run/##KyrNy0z@/z9GJTtRvc5ey1ijWt1K2zDGmitIXUFFwS7TysoguDDP1l7fUFfl//9EBSMFY4UqAA) (and has a trailing one). Input is space-separated.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 17 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
àºÇ╝'♫d▬♣ΩÜEƒ6╩╬ó
```
[Run and debug it](https://staxlang.xyz/#p=85a780bc270e641605ea9a459f36cacea2&i=[%27a%27,+2,+3,+%27b%27]%0A[%27a%27,+%27b%27,+%27z%27]%0A[-1,+0,+257,+%27x%27]%0A[0,+3,+1,+20382876]&a=1&m=2)
This feels like it should be possible to do shorter, but I can't resist the opportunity to use a new stax feature from the last release.
Treating the entire input as a string:
1. Regex replace runs of digits with `eval(match) - 1`. This is the new feature, as the regex block replacement is not a string, but an integer.
2. Regex replace runs of letters by ring-translating them around the lower-case alphabet.
[Answer]
# Python 3, 66 bytes
```
lambda X:[x-1if type(x)==int else chr(97+(ord(x)+8)%26)for x in X]
```
Edit:
I didn't see the solution of Jitse until now. The trick of if''!=i\*0 is awesome!
[Answer]
# C#, 148 bytes
```
(object[] o)=>{var l=new List<object>();foreach(var h in o){try{l.Add((int)h-1);}catch{var c=((char)h+1);if(c>122){c=97;}l.Add((char)c);}}return l;}
```
[Repl.it link](https://repl.it/repls/AshamedLightyellowCompilers)
Ungolfed:
```
var inputList = new object[] {'a', 2, 'z', 6};
var outputList = new List<object>();
foreach (var currentItem in inputList)
{
    try
    {
        outputList.Add((int)currentItem-1);
    }
    catch
    {
        var currentItemPlusOne = ((char)currentItem + 1);
        if (currentItemPlusOne > 122)
        {
            currentItemPlusOne = 97;
        }
        outputList.Add((char)currentItemPlusOne);
    }
}
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
ＷＳ⟦⎇№βι§β⊕⌕βιＩ⊖ι
```
[Try it online!](https://tio.run/##RYoxC8IwEEb3@xUZL9CCdXWSipBN0E0cYnLYQLyWeG2tfz6mOLh973vPdTa53sac5y5EUmh4GOUsKfADtVanMgSvF0ps04JtPxa8VyroSu3FsKf3ioZdoiexkMdjYP9LdIla@xI80F@v903vcq4bWGADH2jAwhZyPcUv "Charcoal – Try It Online") Link is to verbose version of code. Takes input on STDIN, each line being either a single lowercase letter or an integer, and outputs on separate lines on STDOUT. Explanation:
```
ＷＳ
```
Repeatedly input from STDIN until an empty line is reached.
```
⟦
```
Make this expression output on its own line.
```
⎇№βι
```
Is this a substring of the predefined lowercase alphabet?
```
§β⊕⌕βι
```
If so then print the next letter cyclically indexed.
```
Ｉ⊖ι
```
Otherwise decrement the value and cast back to string for implicit print.
[Answer]
# [Zsh](https://www.zsh.org/), 47 bytes
```
a=({a..z} a)
for i
<<<${a[$a[(i)$i]+1]:-$[--i]}
```
[Try it online!](https://tio.run/##qyrO@F@cWqKgq6uga6hgoGCokKhQqVD1P9FWozpRT6@qViFRkystv0ghk8vGxkalOjFaJTFaI1NTJTNW2zDWSlclWlc3M7b2/38A "Zsh – Try It Online")
```
a=({a..z} a)                  # append extra 'a' to the end to handle 'z' case
for i                         # for i in "$@" arguments
<<<${a[$a[(i)$i]+1]:-$[--i]}
       $a[(i)$i]              # first (i)ndex of $i in list (if not found, set to after last index)
      [         +1]           # increment
   ${a[           ]        }  # value in array at index. if lookup fails, empty string
   ${              :-$[--i]}  # if empty, decrement $i and substitute instead
<<<                           # print to stdout
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~93~~ 86 bytes
```
f(int**s){for(char**p=s,*z;z=*p++;)64&*z?*z=*z-'z'?++*z:97:sprintf(z,"%d",atoi(z)-1);}
```
[Try it online!](https://tio.run/##fZDJboMwFEXX9ldYjtJ4gBY6qnFofiBi1xVlgRiCpdYgDFLriG@ndk277OroXb1731CG57JcloZINTKm6aXpBlK2xcBYn@iAGWES1nMu6OP9FTNHZksT7szuyDkz@@enve4H622ICfC2wkExdpIYGsZUzMtGqvJ9qmp00GNV1c11@wKh7UYfhVSEogsEbhYaW6nOOsuzOMpR4mSAH3Dg8Olx5/HlEd96Rh4GQzALuLETpKpRioiWpu4a4nMpukGrwFaFroOZVP006izlcS4gsMcj9wkk7RaRsDig1IJzawBrr3QrrhtL5/rNcHr6ejq5IOJF@n/oz6Xr//BWvykc/AU76wzBUI/ToKwPzss3 "C (gcc) – Try It Online")
The input is a `NULL`-terminated array of `'\0'`-terminated strings, e.g. `{"a", "b", "c", "17", NULL}`.
-7 bytes thanks to @ceilingcat
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 31 bytes
```
*>>.&{(try $_-1)||chr ord ++$_}
```
[Try it online!](https://tio.run/##PY29DoIwFEZ3nuIOhCqUppTws0ji4ObsQhqDCNEExRQHq/js9dImLt9w7jm5j04NublpCHrYgAmrigWf1VNp8I9xsp7n9qJgVGeIIv/4NVOjge0O2z1Dvx8VDNd7N9WcpoyxUJqaNISCoJBSICcivRqXQmIZaRF4TrGYvP8G3nAaK8SocyyyAtFrUWKsFyqyHJG2FrdPFsjTUpRFLl0pXOxgJn8 "Perl 6 – Try It Online")
Anonymous Whatever lambda that maps each element to the list and attempts to subtract one from it, otherwise incrementing it and taking the first character in the case that `z` wraps over to `aa`.
[Answer]
# T-SQL 2012, 61 bytes
Capital letters needed in input.
Using table variable as input.
```
SELECT iif(x<'a',left(x-1,9),char((ascii(x)-64)%26+65))FROM @
```
**[Try it online](https://rextester.com/IBUMDE60459)**
[Answer]
# SimpleTemplate, 80 bytes
This was written on a language I've made.
Due to limitations in the compiler, I can't reduce it any more.
```
{@eachargv}{@if_ is matches"@\d+@"}{@incby-1_}{@echol_}{@else}{@inc_}{@echol_.0}
```
And now, ungolfed:
```
{@each argv as value}
    {@if value is matches "@\d+@"}
        {@inc by -1 value}
    {@else}
        {@inc by 1 value}
    {@/}
    {@echo value, "\n"}
{@/}
```
And the explanation:
* `{@each argv as value}` - loops through all values in `argv`. (`argv` contains all the arguments passed).  
If the `as <var>` isn't present, the default `_` variable is assumed.
* `{@if value is matches "@\d+@"}` - checks that `value` matches with the regular expression `"@\d+@"`.
* `{@inc by -1 value}` - increments the value by -1 (basically, a decrement).
* `{@echo value, "\n"}` and `{@echol_}` - `echol` outputs the values passed and appends a line at the end.
* `{@else}` - self-explanatory
* `{@inc by 1 value}` - increments the value by 1. If the `by <value>` is missing, it is assumed to be 1.
* `{@echo value.0, "\n"}` and `{@echol_.0}` - `echol` outputs the values passed and appends a line at the end.  
This is required because of the challenge rules: `z wraps to a`.  
When an `@inc` is used on a string, it increments the chars and, once it hits `z`, it wraps to `aa`.  
Outputting the first character satisfies the challenge, at the cost of 7 bytes.
* `{@/}` - closes the `{@else}` above (optional).
* `{@/}` - closes the `{@each}` above (optional).
You can try this on: <http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f>
Each passed argument to `render()` will be a new value that is considered.
[Answer]
## Perl, 64 bytes
```
foreach (@ARGV){$_=~m/[a-zA-Z]/?++$_:--$_;print substr $_,0,1;}
```
]