[Question]
  [
An **[Abecedarian Word](https://english.stackexchange.com/questions/208852/is-there-a-name-for-a-word-where-all-the-letters-are-in-alphabetical-order#:%7E:text=You%20can%20call%20them%20abecedarian,letters%20of%20the%20Latin%20alphabet.)** is a word whose letters are in alphabetical order. Your goal is to write a program that outputs all abecedarian words from a given lexicon.
## Rules:
1. **[Standard Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)** are forbidden.
2. If a word contains punctuation, diacritical marks, or any characters other than ASCII alphabet characters (`A-Za-z`), remove the entire word.
3. Words that are abecedarian in ASCII are not necessarily abecedarian for this challenge. For example 'Maddox' shouldn't be considered abecedarian.
4. Your program should work with any lexicon, but for testing purposes, this one can be used. (If my code works properly) It contains ~~588~~ 587 abecedarian words that follow the above rules. The lexicon does not count towards your byte total. <https://gist.githubusercontent.com/wchargin/8927565/raw/d9783627c731268fb2935a731a618aa8e95cf465/words>
5. As per the request of @Olivier Grégoire, here are the Abecedarian words from the lexicon:
```
A Abbott Abby Abe Abel Ac Acrux Aden Ag Ainu Al Alps Am Amos Amy Ann Apr Ar Art As At Au Av B BMW Be Begin Bell Bellow Ben Benny Benz Berry Bert Bess Best Betty Bi Biko Bill Billy Bk Blu Boru Br Btu C Cd Celt Cf Chi Chimu Chou Ci Cl Cm Co Coors Cory Cox Coy Cr Crux Cruz Cs Cu D Dee Deimos Deity Del Dell Dem Denny Depp Di Dino Dior Dis Dix Dot Dow Dr E Eggo Elmo Eloy Emmy Emory Enos Er Es Eu F Finn Finns Flo Flory Fm Fox Fr Fry G Gil Gill Ginny Gino Ginsu Gipsy Guy H Hill Hiss Ho Hz I Ill In Io Ir It Ivy J Jo Joy Jr K Knox Kory Kr L Ln Lot Lott Lou Lr Lt Lu Luz M Mn Mo Moor Moors Mort Moss Mott Mr Mrs Ms Mt N Nov Np O Oort Orr Os Oz P Pt Pu Q R Ru Rx S St Stu T Ty U V W X Y Z a abbess abbey abbot abet abhor abhors ably abort abuzz accent accept access accost ace aces achoo achy act ad add adder adders adds adept ado adopt ads adz aegis aery affix afoot aft aglow ago ah ahoy ail ails aim aims air airs airy all allot allow alloy ally almost alms am ammo amp amps an annoy ant any apt art arty as ass at ax ay b be bee beef beefs beefy been beep beeps beer beers bees beet befit beg begin begins begot begs bell bellow bells belly below belt bent berry best bet bevy bill billow billowy bills billy bin bins biopsy bit blot blow boo boor boors boos boost boot booty bop bops boss bossy bow box boy brr buy buzz by c cell cello cellos cells cent chi chill chills chilly chimp chimps chin chino chinos chins chintz chip chips chit choosy chop choppy chops chow city clop clops clot cloy coo coop coops coos coot cop cops copy cost cosy cot cow cox coy crux cry cs d deem deems deep deeps deer deers deft defy deity dell dells demo demos den dens dent deny dew dewy dill dills dilly dim dims din dins dint dip dips dirt dirty dis diss ditty divvy do door doors dopy dory dos dot dotty dry e eel eels eery effort egg eggs egis ego egos eh ell ells elm elms em empty ems emu envy err errs es ex f fill fills filly film films filmy fin finny fins fir firs first fist fit fix fizz floor floors flop floppy flops floss flow flu flux fly foot fop fops for fort forty fox foxy fry fuzz g ghost gill gills gilt gimpy gin gins gipsy girt gist glop glory gloss glossy glow gnu go goo goop gory got gs guy h hi hill hills hilly hilt him hims hint hip hippy hips his hiss hit ho hoop hoops hoot hop hops horsy hos host hot how i ill ills imp imps in inn inns ins is it ivy j jot joy k kW knot knotty know ks l lo loop loops loopy loot lop lops lorry loss lost lot low lox ls m moo moor moors moos moot mop mops moss mossy most mow ms mu my n no nor nosy not now nu o oops opt or ow ox p pry psst q r rs s sty t tux u v w x y z
```
6. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
fØẠŒlÞ$ƑƇ
```
[Try it online!](https://tio.run/##y0rNyan8/z/t8IyHuxYcnZRzeJ7KsYnH2v8/3L3lcHvk//@OTs4urlyJSckpqVyOSc4prly@iSkp@RVcbvlFJZVc/nmpXC75eeolnnnJOaUpqSEZmcVAderOKequXOqJAA "Jelly – Try It Online")
-3 bytes thanks to Nick Kennedy
```
fØẠŒlÞ$ƑƇ  Main Link
        Ƈ  Keep elements that are
       Ƒ   Invariant when
.[][.]$    Last two links combined, but [ØẠ][ŒlÞ] is an LCC, so it takes another
f          Filtered to keep
 ØẠ        Alphabetical characters
     Þ     And sorted by
   Œl      Lowercase
```
Basically, "keep elements that are invariant when you filter out non-alphabetical characters and sort alphabetically". Jelly's sort is stable.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
*Ties [a stone arachnid's Vyxal answer](https://codegolf.stackexchange.com/a/225537/94066) for #1.*
```
áʒlD{Q
```
[Try it online!](https://tio.run/##yy9OTMpM/f//8MJTk3JcqgP//49WcnRydnFV0lFQSkxKTkkFMRyTnFPAIr6JKSn5FSCWW35RSSWI4Z8HVuKSn6de4pmXnFOakhqSkVkM0abunKIO1qiXCDPw8EqlWAA "05AB1E – Try It Online")
```
áʒlD{Q  # full program
áʒ      # all elements of...
        # implicit input...
á       # containing only letters...
 ʒ      # where...
        # (implicit) current element in filter...
  l     # in lowercase...
     Q  # is equal to...
   D    # (implicit) current element in filter...
  l     # in lowercase...
    {   # sorted
        # (implicit) exit filter
        # implicit output
```
[Answer]
# [Raku](http://raku.org/), ~~32~~ 36 bytes
```
*.grep:{!/<-[a..z]>/&[le] .comb}o&lc
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfSy@9KLXAqlpR30Y3OlFPryrWTl8tOic1VkEvOT83qTZfLSf5v7VCcWKlQpqGjW9iSkp@hYJLZl6@gmtObr5CYlJyyuGVdpr/AQ "Perl 6 – Try It Online")
`*.grep:` filters the input list on the provided predicate function, which is combined from two other functions using the `o` function composition operator. The right function (the first to be applied) is the built-in lowercasing function `lc`. The left, brace-delimited function contains the main logic for this challenge. That function contains two checks, separated by `&`.
`/<-[a..z]>/` is a regex that matches any character other than the lowercase Latin letters "a" through "z". The leading `!` negates that test, matching only words containing no such characters.
`.comb` splits the input string into individual characters. `[le]` reduces that list of characters with `le`, which is the less-than-or-equal operator for strings. That's equivalent to `char₁ le char₂ le ... le charₙ`, which is true if the sequence of characters is lexically monotonically nondecreasing.
[Answer]
# JavaScript (ES6), 68 bytes
```
a=>a.filter(w=>(w=w.toLowerCase())==w.match(/[a-z]/g).sort().join``)
```
[Try it online!](https://tio.run/##NchBCsIwEEDRq0hWGbDpCdKNWz1BKXQ6mdaWmJEkWPVGnsODxSq4@PD4C94wUZyvuQriuIy2oG3QjLPPHPVqm63VZDnKyvGAiTWA3c4FM5113WL17OoJTJKYNZhF5tD3UEhCEs/Gy6RH3aqBY3yo/U7hQI7@eL9@IuKUvjqhc3JXHUD5AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 34 32 bytes
```
#~(-:-.&Alpha_j_-.~[/:toupper)&>
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/les0dK109dQccwoyEuOz4nX16qL1rUrySwsKUos01ez@a3KlJmfkK6QpqPsmpqTkV6hbqycmJaekAmlHKK2XqP4fAA "J – Try It Online")
-2 thanks to xash
* `#~` Filter by...
* `(-:]/:toupper)&>` Words that are equal to themselves when sorted by their uppercase values...
* `-.` And then removing...
* `-.&Alpha_j_` All characters not in `[A-Z][a-z]`.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 86 bytes
```
10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
+$0.?v0[>100. >~~31. >' ␕'@
  =0l< o^?
```
[Try it online!](https://tio.run/##S8sszvj/39Ag08qq1spAw9460da@zEo9Wl0DSFmpJ1SrO2g6aGg5WDkYams41GppVRsa6HFpqxjo2ZcZRNsZGhjoKdjV1RkbAil1BVF1By4FBVuDHBuF/Dj7//9dc3LzuXwTU1LyK7hcMvPyuRKTklMOr@RySk0t5qqKquICAA "><> – Try It Online") (The `␕` represents the character 0x15.)
## Verification
It takes a few minutes, but it works:
```
C:\Users\conorob\Programming\fish
λ time python fish.py abc.fish <words.txt >out.txt
real    5m18.932s
user    0m0.000s
sys     0m0.031s
C:\Users\conorob\Programming\fish
λ wc out.txt
 587  587 3209 out.txt
```
## Process
First, I like to get a functional program working, even if it is not golfy. [133 bytes:](https://tio.run/##S8sszvj/39DAwFCPyy7TyqrWykDD3jrR1r7MSj1aXcO@TAEI7Kys1BOq1R00HTS0HKwcDLU1HGq1tKq5FLAAO3UFde04VCm7ujr7MoNoBTuIPZh6cuwV4/L//3fNyc3n8k1MScmv4HLJzMvnSkxKTjm8ksspNbWYqyqqigsA)
```
1001.
>i::}:0(?;a=?v:'['(?v    >::'`{'@)@(*@:@1+(@}**{
                    >' '+^
             >~~?v0[ >1001.
                 >l?!^o
```
There's a *lot* of wasted whitespace in this one. So, first, I'll flip line 3 up onto line 1. Then, I'll reorganize the last two lines to occupy more of the trailing spaces, including reversing the last line. [113 bytes:](https://tio.run/##S8sszvj/39DAwFBPARXYqSuoa5dx2WVaWdVaGWjYWyfa2pdZqUera9jHgeWtrNQTqtUdNB00tBysHAy1NRxqtbSqucCaDaLtwGba1dXZl0GEFPLjFO1zIEyb//9dc3LzuXwTU1LyK7hcMvPyuRKTklMOr@RySk0t5qqKquICAA)
```
1001.               >' '+v
>i::}:0(?;a=?v:'['(?^    >::'`{'@)@(*@:@1+(@}**{
     0[>1001.>~~?v
      o^!?l      <
```
Now that the last line is more flexible, we can move even more of the last two lines into the leading whitespace. [101 bytes:](https://tio.run/##S8sszvj/39DAwFBPARXYqSuoa5dx2WVaWdVaGWjYWyfa2pdZqUera9jHgeWtrNQTqtUdNB00tBysHAy1NRxqtbSquRTq6uzLDKLtwGbacQFV5tgo5Mcp2v//75qTm8/lm5iSkl/B5ZKZl8@VmJSccngll1NqajFXVVQVFwA)
```
1001.               >' '+v
>i::}:0(?;a=?v:'['(?^    >::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>
   l< o^!?
```
I tried reversing lines 3/4, but that ended up longer because the direction changed. But, now that we made more room on line 3, we can reverse the lowercase procedure back onto line 2. However, to do this, we need to make line 3 jump back to its start before it reaches the lowercase procedure. This is easy to do, since we have a spare leading whitespace. [92 bytes:](https://tio.run/##S8sszvj/39DAwFCPyy7TyqrWykDD3jrR1r7MSj1aXcO@TAEI7Kys1BOq1R00HTS0HKwcDLU1HGq1tKq5FOrq7MsMou3A2u0MjPRAatUV1LXjuICsHBuF/DhF@///XXNy87l8E1NS8iu4XDLz8rkSk5JTDq/kckpNLeaqiqriAgA)
```
1001.
>i::}:0(?;a=?v:'['(?v    >::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' '+^
   l< o^!?
```
We can shave that wasted space in the loop using a very questionable technique. [91 bytes:](https://tio.run/##S8sszvj/39DAwFCPyy7TyqrWykDD3jrR1r7MSj1aXQNIWaknVKs7aDpoaDlYORhqazjUamlVcynU1dmXGUTbgXXaGRjpKSgo2KkriKg7aKsAjQLycmwU8uMU7f//d83JzefyTUxJya/gcsnMy@dKTEpOObySyyk1tZirKqqKCwA)
```
1001.
>i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' ␔'@+$1.
   l< o^!?
```
I've replaced the unprintable 0x14 here with its unicode equivalent `␔`. This bit works by generating a string `' ␔'`, which gives the values on the stack `[char, 32, 20]`. The original code computed `[char+32]`, then resumed control flow. We want to use a jump instead of arrow directions, and the point we want to jump to is (1, 20) in the codebox. `@` permutes these three values to give us `[20, char, 32]`. We then perform the sum and move it below 20 (`+$`), giving us `[char+32, 20]`. Then, we push 1 and jump to (1, 20) (`1.`).
We can shave 1 more byte, by using the last bit of extra space on line 4 to save on the `!` character. [90 bytes:](https://tio.run/##S8sszvj/39DAwFCPyy7TyqrWykDD3jrR1r7MSj1aXQNIWaknVKs7aDpoaDlYORhqazjUamlVcynU1dmXGUTbgXXaGRjpKSgo2KkriKg7aKsAjVKwNcixUciPs///3zUnN5/LNzElJb@CyyUzL58rMSk55fBKLqfU1GKuqqgqLgA)
```
1001.
>i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' ␔'@+$1.
 =0l< o^?
```
We can reorganize this once again, to eliminate the first line. This, however, is still, [90 bytes:](https://tio.run/##S8sszvj/39Ag08qq1spAw9460da@zEo9Wl0DSFmpJ1SrO2g6aGg5WDkYams41GppVRsa6HEpKNTV2ZcZRNsZGhjoKdgZGOopKCjYqSuIqjtoq4DlbQ1ybBTy4@z//3fNyc3n8k1MScmv4HLJzMvnSkxKTjm8ksspNbWYqyqqigsA)
```
10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
  ~~?v0[>100. >01.   >' ␕'@+$0.
  =0l< o^?
```
However, this gives us a little more whitespace to play with, allowing us to tuck more of our code into the leading whitespace. [86 bytes:](https://tio.run/##S8sszvj/39Ag08qq1spAw9460da@zEo9Wl0DSFmpJ1SrO2g6aGg5WDkYams41GppVRsa6HFpqxjo2ZcZRNsZGhjoKdjV1RkbAil1BVF1By4FBVuDHBuF/Dj7//9dc3LzuXwTU1LyK7hcMvPyuRKTklMOr@RySk0t5qqKquICAA)
```
10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
+$0.?v0[>100. >~~31. >' ␕'@
  =0l< o^?
```
This has reduced our Unnecessary Space Count™ to 5. At this point, I'm not quite sure where to go. By my reckoning, either the logic (`'`{'@)@(*@:@1+(@}**{`) must be golfed, or the fundamental structure/approach to the problem must be reworked.
[Answer]
# [R](https://www.r-project.org/), ~~89~~ 76 bytes
```
function(d,`+`=lapply)d[gsub('[^A-Z]',21,d+toupper)+utf8ToInt+is.unsorted<1]
```
[Try it online!](https://tio.run/##HcyxDoIwFAXQ3c9gKU3RBFwcZKiACYNxYZJgoLxWSUhLaJvIH/kfflilLDcnN@/d2YnUCSt7MygZQtSSNh27aRoXDPVLWxai@kn3jwZFSRwBMcpOE58xsUacKlVKQwZ9sFKr2XA4x40TYR/uEL1keYGiHepYD9yDsgy25tYBqI/XdX1aPO7SnwS5ksiUsh8t8Oo96GDtKEMZoMLTT/2@mzqfcXIMMHbuDw "R – Try It Online")
Implemented as function taking a strings vector and filtering non-abecedarians out
Steps:
1. make the string uppercase
2. replace any non letter character with `'21'` (i.e. two descending ASCII char)
3. turn strings into ASCII code points
4. take only the strings where the code points are sorted
[Answer]
# [Ruby](https://www.ruby-lang.org/) -p, 29 + 1 = 30 bytes
```
$_=$_[/^#{[*?a..?z]*?*}*\s/i]
```
[Try it online!](https://tio.run/##KypNqvz/XyXeViU@Wj9OuTpayz5RT8@@KlbLXqtWK6ZYPzP2//@S1OISrpL8RCCZmJScwuWbz@Wfy@WYkpqTmw@krMF0YpIeUMq9ND0nE8z/l19QkpmfV/xftwAA "Ruby – Try It Online")
Uses a regex composed by the letters "a" to "z" joined by "\*" to find the words.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `a`, ~~9~~ ~~8~~ 6 bytes
*-2 thanks to @Aaron Miller*
```
'⇩:sǍ=
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=a&code=%27%E2%87%A9%3As%C7%8D%3D&inputs=berry%0Aabcdc%0Aabcd%C3%A9%0Aaccess%0AMaddox&header=&footer=)
```
'⇩:sǍ=   # Full program
         # All inputs (implicit)
'        # where...
 ⇩       # the lowercase version...
     =   # is equal to...
 ⇩:s     # the sorted lowercase version...
    Ǎ    # with only alphabetical characters
         # Implicit output
```
[Answer]
# [Zsh](https://www.zsh.org/) `-F`, 28 bytes
```
grep -xi `printf %s* {a..z}`
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwbLi1BIFXbelpSVpuhZ70otSCxR0KzIVEgqKMvNK0hRUi7UUqhP19KpqEyBKFkCpmymJXIWFhVyJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5RWVVVzZfvklJZVcSSlpGVk5eQVFJWUVVVx6XInqxVyOSak5QAqX5qpKLt_ElJT8CohlAA)
An abecederian word is one which matches the regular expression `^a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*$` (case insensitively).
This regex is constructed by `printf %s* {a..z}`, and then matched using `grep`. The `-x` implicitly adds the `^` `$`; the `-i` option makes matching case-insensitive.
[Answer]
# BQN, 28 bytes
```
("a{"⊸⍋⊸/≡∧)∘+⟜(32×'a'⊸>)¨⊸/
```
[Try it here!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAgKCJheyLiirjijYviirgv4omh4oinKeKImCvin5woMzLDlydhJ+KKuD4pwqjiirgvCkYgIk1hZGRveCLigL8iYWJjZGUi4oC/IkFiY2RlIuKAvyIuYSLigL8iYX4i)
Thanks to @DLosc for 3+4 bytes saved!
## Explanation
BQN doesn't have builtins for string manipulation, so I had to manually recreate lowercasing/filtering non-alphabetical chars.
* `...¨⊸/` Filter lexicon of words...
* `+⟜(32×'a'⊸>)` Lowercase word
* `≡∧` Check if sorted lowercased word matches...
* `"a{"⊸⍋⊸/` Remove `[^a-z]` from unsorted lowercased word
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-rl`, 14 bytes
```
$LE"az"JLC_FIg
```
[Try it online!](https://tio.run/##K8gs@P9fxcdVKbFKycvHOd7NM/3/f9/ElJT8Ci7HxOSM1DwglZNZmZgBo9WLgayifKB4UlJiMYTMTAHR@SUlUEodLF4JJsDslNIcCAnmpYIwhJUDJtSL/@sW5QAA "Pip – Try It Online")
### Explanation
```
             g  List of lines read from stdin (due to -r flag)
           FI   Filter on this function:
        LC_      The string, lowercased
   "az"J         and inserted between "a" and "z"
$LE              is sorted in ascending ASCII order (fold on string-less-than-or-equal)
                Output each element of the result list on a separate line (-l flag)
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~18~~ 14 bytes
-4 bytes thanks to [Adám](https://codegolf.stackexchange.com/users/43319/ad%C3%A1m)!
```
⊢⌿⍨(∧≡∩∘⎕A)¨∘⌈
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HXokc9@x/1rtB41LH8UefCRx0rH3XMeNQ31VHz0AoQq6fjf9qjtgmPevsedTU/6l3zqHfLofXGj9omAtUEBzkDyRAPz@D/aQrqiUlJyeoK6mXhFZFVQPrwksQUIOWbmJKSXwFk6CWqAwA "APL (Dyalog Extended) – Try It Online")
`¨∘⌈` for each uppercased word:  
`∩∘⎕A` the word intersected with `'AB ... YZ'`, keeping duplicate letters.  
`∧` the word sorted ascending.  
`≡` are those strings equal?
`⊢⌿⍨` select words from the input where the result is a `1`.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 74 bytes
```
l->l.filter(s->{int p=65,r=1;for(var c:s)r=p>(p=c&95)?0:r;return p<r*91;})
```
[Try it online!](https://tio.run/##bVDRatswFH3PV@hpsUtj1ocO6tQZacZYYGVjDgxW@nBjy4lSWRJXcoYp@fZMunLSDPrgc8495@peyTvYw2RXvxxFazQ6tvN1JnR2NR1dOp0TMms6VTmh1buhdcihDVElwVr2CEKx1xFjpltLUTHrwHnaa1Gz1mdJ6VCozdMzA9zYlFoZ@zqsuC9p3H21BXx6nl3/X85Yw4qjnMz8nYR0HBM7mb0K5ZgpPt1eY3EzbTQme0BW5TbFwswSU1Qf7m7Tzx9znCJ3HSpm7vHq7mZ6SI9TWh76pVDcsoIp/vf8Lx66puHI618car8rREtlOhcvNbhlbx1vM6HSlIYxltGs5Fy2YIZH57nTC/@UOSL0aVxOQCcK1mRgjOwTKod8mK87lxk/w0kV4/em@xuetxrOX5K3w3k@nE6zSnfKJSnNP4wOx/loPrajOcEDwWPABcHqW6AlwZcyEIU/vocvqHKxpLSkakXp6mfA37HhD8EqIFRbrjxJ0cP2xBSg9v56DTaiqANr5wYak98TkK47GZEqHr6oJMGgAWtiS9OJY4I15@osBk@B2/ZvilxR70CdODobEGGJkFyFvYpjREoRttCeeHBifa4CWZA62N0OPPbWCiUuFLUOWl3Isf0H "Java (JDK) – Try It Online")
## Credits
* -2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)!
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 68 bytes
```
lambda x:[y for y in x if y.isalpha()and sorted(f:=y.upper())==[*f]]
```
[Try it online!](https://tio.run/##Dc2xCsMgFEDR3a8QF7VDli4l4JAmKXQoXbolGUyfEsGqqIH49Tb75dxQ8ubd9RZiTYIQ0t37YURy/YJC3drDiF4SwB/o4WMu6O0UGryj@em@dgf12Uw6O9oDHRGVJ9CkYE1mZHaEIy3mauVvBYmPdipY@4gLNg4f2GhcGpOkDZtkXDrA6TwoYLoVpdlDUJFxLsR00ctSQzQuM80S5/UP "Python 3.8 (pre-release) – Try It Online")
Yeah! now Python ties with Javascript!
-24 thanks to @makonede
-5 thanks to @hyper-neutrino
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, 68 bytes
```
[ [ >upper dup [ LETTER? ] ∀ swap [ <= ] monotonic? and ] filter ]
```
[Try it online!](https://tio.run/##HY7NasJAGEX3PsUtuvYBqm1MNEih7cLGlUj4MvOpg3FmMj@kIkKXfc6@SDrt8hy4h3sgEYwbth8v7@tHkBdK4cxOc4sLhdM0aiWM5H/A0ZlolT7CcxdZC/boeljHIVytUzpgNhp1/Q1vJKX5RF4sVyWoECuGIIe8afiKh8V4gprqphY1DqptcR922OE5WssOMtoEr2VVlZsMe/x8f8H39CfnT4kvRptg0q0MpGUSKRHSbj8ISq3p8As "Factor – Try It Online")
* `[ ... ] filter` Take words from the lexicon for which the quotation returns `t`.
* `>upper` Uppercase the word so case doesn't mess with the test for monotonicity later.
* `dup [ LETTER? ] ∀` Does it only consist of (uppercase) letters?
* `swap [ <= ] monotonic? and` And is it also sorted?
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 61 bytes
```
^
$'¶
T`L`l`^.+
^
$%'¶
O`\G.
%)`^(.+¶)(\1|.+¶.+)
Gi`^[A-Z]+$
```
[Try it online!](https://tio.run/##FcpRCoIwAIfx9/85lCmjQUdYOiUofPGpbGy6QYJsYAsKOpcH8GJL3z5@fLMNo9MxSiRkXdCqi5qUZBQbpLs0qqsZ0lzJjNF1ybPu@NuD0RyoRyXv/HB70CRGfipKAd0PxoL3hRG4amP8B5WfwxeNsyi9I@HshultbPscX9tHCkMEiP4D "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
^
$'¶
```
Duplicate the word.
```
T`L`l`^.+
```
Lowercase the duplicate.
```
^
$%'¶
```
Duplicate the lowercased word.
```
O`\G.
```
Sort the letters of the lowercase duplicate.
```
^(.+¶)(\1|.+¶.+)
```
If the sorted lowercase equals the lowercase word, delete the lowercase and sorted lowercase, otherwise delete everything.
```
%)`
```
Run the above stages on each word separately.
```
Gi`^[A-Z]+$
```
Keep only words containing letters.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
ΦＡ⬤↧ι›№βλ∧μ‹λ↧§ι⊖μ
```
[Try it online!](https://tio.run/##PYxBDsIgEEWvQrqBJngCV0jVNKnRhbumCwqTlISCAar19Ag1Opv/8/PeyEl46YRJ6ea1jeSkTQRPWvtYIqkpYsaQzr3ASxGA6LycPYiCcLdkfqTIFMwqMlPUQQjE5PwbLLZWwUo0RQ1IDzPYCJmtf7dPqe8rduDNsaKoEqNUUAobudqWi1DKraWdnI/vUq52QxpncX4vzaLgPunw1TBXeBOxqIYh7Z7mAw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 Ａ                  Input as an array
Φ                   Filtered where
    ι               Current element
   ↧                Lowercased
  ⬤                 All characters satisfy
      №             Count of
        λ           Current character in
       β            Predefined variable lowercase alphabet
     ›              Is greater than
          μ         Current index
         ∧          Logical And
            λ       Current character
           ‹        Is less than
               ι    Current element
              §     Indexed by
                 μ  Current index
                ⊖   Decremented
             ↧      Lowercased
```
[Answer]
### perl, 59
```
say if /^[A-Za-z]+$/ and lc($_) eq join "",sort map {lc} @F
```
[Try it online!](https://tio.run/##ncpNTgMxDEDhfU5hVZUGBENh0RUb2MyuF2hVkEk8g2lqhzhpKYirE36OwFt@eolyXLZqBIfl1c31bTM8AY@weNjc92vs37cX8wWgBIj@bP54DvQKL8oCs9mlaS6wxwQf0X/C3dCa1QkzBfhnbiKhjJHNeK@ducCY2Yq5UfORpDg7oj0/Vb@LLJNbsd8xuSqGIfyJVSko5jzmoiq/VGVEzkJmbvWz6ZsboqZ0@tJUWMVaP3Qd9BHlGw "Perl 5 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 68 bytes
```
lambda x:re.findall(f"^{26*'%c*'}$"%(*range(65,91),),x,10)
import re
```
[Try it online!](https://tio.run/##HY3BCoIwHIfv/6cYI9kmElkkFHgwNegQXTpGMN1MQafMBUr0Ll17Dh/MzNPv8v2@r@lNXqvNmPm3seRVIjjq9lous0IJXpY0w/fX2rOJldrkvcAWtTVXD0m9rbNzmcOcznFXDIqqqbVBWo5GtqZFPsIYAwSHMIqBJ6mQECShiOE4YT3AmQtRd3BREqJaEXNSafkU8poX7QSSUJAYCIfhM1//guELHE0LMJsbXShDMzrnGBt/ "Python 3 – Try It Online")
Python had already a solution ([here](https://codegolf.stackexchange.com/a/225424/103772)) but it didn't worked on tests with char like (éèàÈ...).
## How it works :
* `re.findall` returns all the occurences of a given pattern in a given string.
* `f"^{26*'%c*'}$"%(*range(65,91),)` produce the pattern `^A*B*C*...Y*Z*$` which will match any upper abecedarian word.
* `10` (`=2|8`) passed in argument to `re.findall` sets the flag `re.IGNORECASE` (`=2`) to disable caseCheck in the string and the flag `re.MULTILINE` (`=8`) which apply the pattern to each line of the string.
[Answer]
# [Perl 5](https://www.perl.org/) + `-lF -M5.10.0`, 28 bytes
```
/@{[sort map lc,@F]}/xi&&say
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoiL0B7W3NvcnQgbWFwIGxjLEBGXX0veGkmJnNheSIsImFyZ3MiOiItbEZcbi1NNS4xMC4wIiwiaW5wdXQiOiJBYmJleVxuQWJob3JcbkFicmlkZ2VkXG5BY2VzXG5BZGRlclxuRm9ydHlcbkhlbGxvXG5NYWRkb3hcbk9uZVxuU3R1In0=)
[Answer]
# [Red](http://www.red-lang.org), 88 bytes
```
func[b][a: charset[#"a"-#"z"]remove-each w b[any[w <> sort copy w not parse w[any a]]]b]
```
[Try it online!](https://tio.run/##LYsxDsIwDEV3TmG5cy9QIW7Awmp5cBxHXWgqJ1DKjTgHBwuNxPSenv53i@1mkfiUppYei1Jgkgl0Fi9WaUDBccA3sts9P2000Rk2CCTLThucL1CyV9C87kdecoW1P2HrAxBmDtxWz8EgAWEw9x0BJWjUP7@fLqpWyiFXiTG/kKH9AA "Red – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0 [`-f`](https://codegolf.meta.stackexchange.com/a/14339/), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Not entirely sure I've understood the spec correctly.
```
¶ñv o\l
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&flags=LWY&code=tvF2IG9cbA&input=WwoiYWJjIgoiY2JhIgoiZEVmIgoiROlmIgpd)
[Answer]
# Java 8, 127 bytes
```
l->l.filter(s->(s=s.toLowerCase()).matches("[a-z]+")&java.util.Arrays.equals(s.chars().toArray(),s.chars().sorted().toArray()))
```
[Full Program (must be run locally)](https://tio.run/##jVJNbxoxEL3zKywOla0WrwLlqwSkNuqhElWkVDlFORjvLJh67a1nNhtS5bdTLxA@CpU6F8szb2bevJmlelKtZfpzbfLCB2LL@JfGyy9llkGA9A5UCmHU@Cv87fbrs4aCjHfnMVeU9IMCqPxStgOS93fTU2dJxsqpQbrgzkqn60by3qmwui0gKPLhAhA3PeWNtxZ0hOC/MVt6o0ajKGfWaKatQmTflXHsd4NF2/mRFMXnyZuU5THKY6Jx84dHpsIcBaNF8BWyIzl2@bWd8L3etrzeFphMWDZe29YkjmcsQeDYmnAcoyQ/9RWEG4XAhZC5Ir0A5M0H1Xp5fN8U7w6zfA5BrVDCr1JZ5Cj1QgXkIpbYRLj4cPBhlAHS46AQ6zeioz3lU5LMwrPRcaYxc1Cx05vg@6Q3qzFnyz@HHcPjIfDmgqjAT0kyj/uXc0OLclYihNiYwJHUPk@qeo65cclg2O53e90kqCpJh/1Bp9fu637nqt0bZLP2sNNV8aN6VwOlBjDs6uxjBFc@pNgU0hfgtty4OKMVxbbGRanFQY76IvdiBMDSUtQik6oo7Irv1BGR4ebi@OHy6jXG3KjykbYrJMilL0kWsSJZx7cl/wcj0bzAvtxr43X9Bw)
# Java 16, 124 bytes
```
l->l.filter(s->(s=s.toLowerCase()).matches("[a-z]+")&s.chars().boxed().toList().equals(s.chars().sorted().boxed().toList()))
```
[Java 16 added the `Stream#toList` method.](https://jdk.java.net/16/release-notes#JDK-8180352)
[Answer]
# [Julia](http://julialang.org/), 55 bytes
```
x->x[@.all(isletter,x)isascii(x)issorted(lowercase(x))]
```
[Try it online!](https://tio.run/##FYhRCgIxDAX/e5IUdMEDKCKihxBZsk0KkeBKU7HbG3kOD1a3PzPz3uOtgrvS4r6V7aHcjgOqgphyzpw2xYuhBRHoZXPKTKDzh1NA4/X090ZiL8UFIiRGUnmygfe@4Smc@eJwCvT7utrdx0Acu0c3rnTX6qKo1j8 "Julia 1.0 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 164 bytes
```
#include<stdio.h>
a;main(){for(char*s,w[99];!feof(stdin);!a&&printf("%s\n",w),a=0)for(scanf("%s",s=w);*s;a|=tolower(*s++)>tolower(*s)&&isalpha(*s))a|=!isalpha(*s);}
```
[Try it online!](https://tio.run/##TYtNDoIwGET3vQUYSQtI3JoKC2P0EGrIZ3@kSW0JxTRBPZDn8GBI3ehmXt5khi0ujI3jTBmmb1ysXc@VLZoKAb2CMpjcpe0wa6BLXe4Pq9WJRlJYicPQEBpBkrSdMr3E8dwdTZx7kkO5JOHmGJhvH@eu9ISmjsKj7K22XnQ4dVlGqp@RJFEOdNtAEDItoz@nz3GEDduKHYIz4@8XGgKDFFzIwBrVU6L9gKTSevgA "C (gcc) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/language/), 67 bytes
Assumes the Notebook environment. Otherwise an extra `Print` needs to be added around the last part of the code (as is done in the TIO link).
```
f=(a=Characters@ToLowerCase@#;a==AlphabeticSort@a)&/@#&;l~Pick~f[l]
```
This code assumes a lexicon has been defined previously and saved in the variable `l`. It maps the function `f` over each word in the lexicon and keeps only words for which `f` returns `True`. `f` in turn takes in a word, lowercases it, and then puts the letters in the string individually into a list. It returns true if the list does not change when `AlphabeticSort` is run on it. `AlphabeticSort` takes in a list of strings and sorts them in alphabetic order into a new list. The `ToLowerCase` function call is needed because `AlphabeticSort` sorts lowercase letters before their uppercase version, and so `f` fails to find "Oort" because it gets sorted into {"o","O","r","t"}, which doesn't match the original character order.
[Try it online!](https://tio.run/##PYtBCoMwFETvEkFaKPQA8iHitguh7sTFJEQSGk2Jv5S26NVj3HQz8xjeTGBrJrDTSJ5@olYqMIvLAZ9crxn@aaHMYfg8QOmcX4g1jXQCNRYRmk1cZBdu4W1ig8XIogJR/b/eQ2SJc3mVRVm10c3c@611@rGNvR@GlHY "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 9 bytes
```
)zz:aa:so
```
[Try it online!](https://tio.run/##LVbLdtw2DP2Vu@0vZDcvxxN7bDdJm7Y7SaQetkgqpOR5rPtr/S73XijHxCUIgiAAAhrXSx59@bn4j7P7@O12@1RVn0r6@LhV@J7y8t@/2GBT12meNV0JXjRi03Dk5YKN8xGbDpshLthwY5wKNoEjaeaRyP0pY6NBM5QSqfuOLbanH9h6jm6IxHE0SGdOWsd4Fd4IOYulga0vRSBunikcON4SQacJFL1hOy7YMgJsM7bzgh12Djs/zti12PWDKFDcJwJXI3YBu8SRciHytl26kDhnDkZKuGHHzQV77L0nDQqSE93YMyl7BbD3gSTP936asB84YiKkTKD6cME@zaQz9hkHHLou4TAGAa87hCCQB4dI8wfqEBfc4W5gLgUFd2MSUeku4I6e3mWOKz7j8zCKBHLisy4nlIU4FQqWK@5xL437gam8T7i/4YgjBceIY8Ix4zjj@H7FF3xJHGQyHvAQec@D7nzIeMRjxCPjeFRxPDKNjxSSI8M8nXCKOCUOhn2ypJ4SX@@UijgeOVEuKceMJzyldzxNeMaz1J5zxnPB8w0veJnxsuB3fMXXBV8v@IZvM8eC7/h@xR/4Ez/wF/7GP6hQ1bXKQ9NVSP@q2gt6@mGo3VGbuqeql9sNVdP4ONs0rZNsNE0qWnmR1n1KQp5tKHccRj6vWDQJzIhLIuMk4yWscXKe6avalkVQtUnutaROJV@xDKqeg/mu@Igk6g9BJCaLjOE@H4uk89YuQpMKgvk96hAPBxZWFSYRBZEjSlXxsjwqeZiNuKCCIueS7l1Rg@1ee6PWoBhehVEwGZg0GxhrMBPaQdiJhrii9rpkYrGMo147XtMqkflfEulFgdq/VtPXZpi1WauCBdK0aZUVQ/FRpGVS3dfyRRmr7QTfslZt1labxBVm4Qo8kiaRdsoKkunwhUSeVVqznayI@HVs0CggQVqx2CRkFA0/OyRp9OaoTVdNfB9Dk0WDtOIqWXG@aTLVVVM26bRMpMlgWnnt0tFGX6Zm1N5oQsXfqFQaxk@aDIrQgLsmM5FsKSON3WB7NMnYGxnQJ7HhqzQFDs7zqycowsnA2GwglnXuVDrOPpdOiXKWG@dZoQKxUWSM1KMUzyIySpyzvDlLm2NrOLWGY8acckTgKSbIKT9uyLOBVLUsgtmW7ywgdqhTBTirAKdwnT5uTo4wWpJ0KfHw/LqTCkHrttXHw3ediEJ1NqtaRKaHgrPY/BhEZDiHifa8LRb4SBdY1iJKOC5o0SrI1oJsLUhiMDBBkCCKonESZpExfKp2MBDR3MCybEfFaFg0TQaMtbWKIBbDM2ER8ZzuVS200jYtmVDIAm1eRGSYjFbF36HrVSqd/O/Mf6LWgVep@a31O/sF6vQwnTzt5E9nP2OdOWJoizM6/kPBnHbJiHqmRreY8Y5d14P9ZO20dtPaTL2uZSuJJItaTaJJm5NkRgLuJQ4a760NekXd29JWmb4wLlhsve2dMUB32pXqW@taBqjfZvtpVqC8gsYHPvErXnnulR3zhrcfeItcCZhGTme8FYzg52KUF6N5IbwKZ4wmNJm@gJajUc6MtnkmXUBHAgLTFPTUwV46qKGDTASaCDIRdDhYfu0XIvA4U8RaZFlF8IMTeTyq2eWknOMLJJhP@iXjLmW8cMJEZ6ZCIz@Rwev4x4BmzCyfBe8444Irbv8D "Burlesque – Try It Online")
```
)zz # Map to lower case
:aa # Filter all alpha
:so # Filter sorted
```
[Answer]
# [brev](/brev) 166 bytes!
```
(import srfi-13(chicken sort))(for-each print(filter(o(fn(equal? x(strse x "^[a-z]+$"(as-list(fn(sort x(bi-each < char->integer))))#f)))string-downcase)(read-lines)))
```
]