[Question]
  [
For the purposes of this challenge, a *polyphthong* is defined as a contiguous slice of a String, that only contains vowels, and has length at least 2. Given a non-empty String as input, your task is to output all the polyphthongs it contains.
For example, `"abeoic"` has the following contiguous slices (space-separated):
```
a b e o i c ab be eo oi ic abe beo eoi oic abeo beoi eoic abeoi beoic abeoic
```
Removing those that contain anything other than vowels, or have length smaller than 2, we get our desired polyphthongs:
```
eo oi eoi
```
---
Your submissions must abide by the following rules:
* You can choose either lowercase or uppercase for I/O, but the output case must match the input case.
* The vowels are `aeiou` (for lowercase) and `AEIOU` (for uppercase). `y` / `Y` is not considered a vowel.
* The input will only contain printable ASCII.
* If a polyphthong appears multiple times, you may choose to output it only once or output all its occurrences.
* Any reasonable I/O format and [method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) is allowed (lists of characters are also fine, for both input and output).
## Test Cases
```
Input  ->  Output (lowercase)
r67^^()*6536782!87                -> []
programming puzzles and code golf -> []
aaand... i won!                   -> ['aa', 'aa', 'aaa']
abeoic                            -> ['eo', 'oi', 'eoi']
yah eioo ala                      -> ['ei', 'io', 'oo', 'eio', 'ioo', 'eioo']
@yabeeeayio__e                    -> ['ee', 'ee', 'ea', 'io', 'eee', 'eea', 'eeea']
0ioen0aaiosnjksd                  -> ['io', 'oe', 'aa', 'ai', 'io', 'ioe', 'aai', 'aio', 'aaio']
```
Note that for test cases 3 and 6, you may output `'aa'` and `'ee'` respectively only once (See the fourth rule).
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest submission in bytes in every language wins!
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~102~~ 97 bytes
*thanks to @JonathanFrech for -5 bytes*
```
w=input();l=range(len(w)+1)
print{w[a:b]for a in l for b in l if b-a>1<set(w[a:b])<=set('aeiou')}
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9w2M6@gtERD0zrHtigxLz1VIyc1T6NcU9tQk6ugKDOvpLo8OtEqKTYtv0ghUSEzTyFHAcRMgjAz0xSSdBPtDG2KU0s0IAo1bWxBHPXE1Mz8UnXN2v//lRKTUvMzk5UA "Python 2 – Try It Online")
lowercase I/O
[Answer]
# JavaScript (ES6), ~~77~~ 75 bytes
Expects input in lowercase. Outputs unique polyphthongs without repeating.
```
w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r
```
### Test cases
```
let f =
w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r
console.log(JSON.stringify(f("r67^^()*6536782!87")))
console.log(JSON.stringify(f("programming puzzles and code golf")))
console.log(JSON.stringify(f("aaand... i won!")))
console.log(JSON.stringify(f("abeoic")))
console.log(JSON.stringify(f("yah eioo ala")))
console.log(JSON.stringify(f("@yabeeeayio__e")))
console.log(JSON.stringify(f("0ioen0aaiosnjksd")))
```
### How?
We recursively build the tree of all possible polyphthongs, pruning branches as soon as the current node is not contained in the input anymore, and saving all matching nodes of at least 2 characters.
```
w => (                      // given the input w
  r = [],                   // r = array of results
  g = s =>                  // g = recursive function taking s
    w.match(s) &&           // if w contains s:
    [...'aeiou'].map(c =>   //   for each vowel c:
      g(s + c),             //     do a recursive call with s + c
      s[1] &&               //     if s is at least 2-character long:
      r.push(s)             //       push it into r
    )                       //   end of map()
)``                         // initial call to g() with s = ''
&& r                        // return r
```
[Answer]
## [Retina](https://github.com/m-ender/retina), ~~23~~ 20 bytes
```
M!&`[aeiou]+
r!&`..+
```
[Try it online!](https://tio.run/##DccxDoJAEAXQfm5BoUFJNkTjLqWdlScwAl@Z4GDYMYMWe/qV1z3jr0TkTXnp87XY9jew6O9eka1xrsrZfGjbcrf3p6MPzaFoAn1MR8M8SxwJQBycc4QHqzwp4UXntIYZSbTrmGpRjjUgusTpvQx/ "Retina – Try It Online")
This prints all occurrences of a polyphthong.
### Explanation
Retina does have a way to get all *overlapping* matches, but what this really means is that it will look for one match from each position. So if there are multiple matches from the same position, this will only return one of them. The only way to really get all overlapping matches is to use this feature twice, once matching left to right and once right to left (so that we first get the longest possible match from each possible starting position, and then we also get all matches for the possible ending positions).
So the actual program:
```
M!&`[aeiou]+
```
Get all overlapping runs of vowels. What this really means is to get all suffixes of all vowel runs.
```
r!&`..+
```
Now get all prefixes which are at least of length 2, by matching from right to left. The `M` is implicit here, because it's the final line of the program.
[Answer]
# [QuadS](https://github.com/abrudz/QuadRS), 20 + 1 = 21 bytes
```
⊃,/⍵
[aeiou]+
1↓,\⍵M
```
with the `o` flag
[Try it online!](https://tio.run/##KyxNTCn@//9RV7OO/qPerVzRiamZ@aWx2lyGj9om68QAhXz//weL/c8HAA "QuadS – Try It Online")
In order of things happening:
`[aeiou]+` on each match of this PCRE
`,\⍵M` prefixes of the Match
`1↓` drop the first one (which has one one vowel)
`,/⍵` concatenate all the lists of prefixes
`⊃` disclose (because reductions `/` enclose)
---
This is equivalent to the Dyalog APL tacit function:
```
{⊃,/⍵}'[aeiou]+'⎕S{1↓,\⍵.Match}⍠'OM'1
```
[Try it online!](https://tio.run/##Jc49CsJAEAXg3lOM1fobjWKS0guIhaV/jMkmrq47IVEkipWQQogIYu8lvNBeRJfYPb43Aw9j2Q4ylBR9v6HOH2d9u7Y6uvhc2BS5oMO8yfT9NTnbOn@2ZqawRrj31xddvNl4xGzzBixx3MWiVm84g77jer2q57KK4TihKMHdTqgI4sPpJHkKqALwKeAQkQzLK0RjlmWBgCOp6t9WnIRfxgzXYIYQoMQShplpOcdM0HLJS@oK4qqLKChVm20asB8 "APL (Dyalog Unicode) – Try It Online")
[Answer]
# Mathematica, 92 bytes
```
Select[Join@@Partition[r,i,1]~Table~{i,2,Length[r=(S=Characters)@#]},SubsetQ[S@"aeiou",#]&]&
```
  
[Try it online!](https://tio.run/##BcGxCsIwEADQXwkpFIUM1T0QcBOHStxChmu8mtM2geQ6if31@N4KHHEFpgBtFlo0iwsGdtdMyZgRChNTTq4oUie/P2BacP@SOqsbphdHV/TB6kuEAoGx1KPp/E/ZbarId2eNBKS8SdX53vdtLJRYmNnJgTKmAYByTe9PfUrf/g "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~138~~ ~~135~~ 134 bytes
```
s->{String e,x="";for(int i=0,j,y=s.length();i<=y;i++)for(j=y;j>i;x+=e.matches("[aeiou]{2,}")?e+" ":"")e=s.substring(i,j--);return x;}
```
[Try it online!](https://tio.run/##NY8xb4MwEIX3/IqTJ7uAVXWsA926dcoYZTDESc4BG@FzBEL8duom9JY7vft0957VD1343jh7vq/Y9X4gsEmTkbCVl@gaQu/km@pj3WIDTatDgB@NDuZdIE1J@96o/YEGdNccXr2CEUpYQ1HNLwFMPpaMqYsfODoCLN9zm09lkK1xV7pxoXBfTgqzTPwxNs22QjVmpZGdpuZmAmdHbdDH0/yRL0x8mYwB@2RMmHQmxDo8P3HMbVEINRiKg4NRLet/gM3zw@MZuhSDv7wdT6BFigRbHaZAppM@kuzTnvgodd@3E2e6Nh4bJoR6wstuWX8B "Java (OpenJDK 8) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~34~~ 29 bytes
```
(*/@e.&'aeoui'*1<#)\\.#&,<\\.
```
[Try it online!](https://tio.run/##RYpBCoMwEADvfcUWwaiU1LZUPVjwIaJsdRNjNSuKB/182kvxNDAzvXPqJSGIrgVJXyDxakR0y72wLKXnX/IfHDUdgwIxJ2lVBWGUPB9Jmt3PWSpO/zbNrGccR2M1TOu@D7QA2hYabgk0D@pYN@yADDPggIctNnwTEW6G65oOHxsmGyMaXmz/WVrhvg)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
ẆḟÐḟØcḊÐf
```
[Try it online!](https://tio.run/##y0rNyan8///hrraHO@YfngAiZiQ/3NF1eELa/8Ptkf//Jyal5mcmAwA "Jelly – Try It Online")
# Explanation
```
ẆḟÐḟØcḊÐf  Main Link
Ẇ          Get all (contiguous) sublists
  Ðḟ       Filter; remove all elements where the result is truthy:
 ḟ  Øc     Filter; remove all vowels; if it's truthy, then it contains non-vowels
       Ðf  Filter; keep elements where the result is truthy:
      Ḋ    Dequeue; return all but the first element (truthy if the length was at least 2)
```
-4 bytes thanks to Mr. Xcoder
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 104 bytes (99 bytes with lowercase only or uppercase only)
Yeah, it leaks - so what?
```
#include<string.h>
a;f(char*s){*s&&f(s+1);for(a=strspn(s=strdup(s),"AEIOUaeiou");a>1;)s[a--]=0,puts(s);}
```
[Try it online!](https://tio.run/##dc/BToNAEAbge59iikmzi4VQjdAE2@jBgydPnmrbjMsCq7BLdiCGNn12XPSgF24z@b@ZzIigEGIYrpQWVZfJe2qt0kVYbmeY5kyUaH3iZ58Wi5zR9YqnubEMN45RoxmNRdY1jPjSe3x6fnlFqUzn8RS3q5TTDoNgv4mWTdeSM@llULqFGpVmfHaeAcBP4u3cxNjlzLNxcjgw7sd3t3GyvpmvE5f9qv2b/gcbawqLde3OdVtOp0oSoM5AmExCYap8Yg7RqTAMQcGX0fMp9S6NEhNhjyW4Pw1ghRPkoXcbpMRemeNRTqBIGakjRGVIf3xS9sdGcxm@AQ "C (gcc) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 137 bytes
*outgolfed by [Mark](https://codegolf.stackexchange.com/a/147847/67312)!*
```
function(S)(x=unlist(sapply((s=el(strsplit(S,"[^aeiou]")))[nchar(s)>1],function(x)substring(x,1:(n=nchar(x)),rep(n:1,e=n)))))[nchar(x)>1]
```
[Try it online!](https://tio.run/##RcxBCsIwEEDRvacoWc1AXHRbjJfosihMa2oDcRIyCaSnjxVB9/@/1LybE6UdXjZv4SF4WrvLua2Fl@wCw4hQTWHvJINQjH4HEGM9SE4SvcswajXdybpQbgoRJ142SiB47W/6x1SUMh@L4ydU3Q/A5ttVRJ1sBB56bQ0j/on6IdoKaqetO/zQkSeF7Q0 "R – Try It Online")
```
function(S){
 s <- el(strsplit(S,"[^aeiou]"))            # split on non-vowels
 s <- s[nchar(s)>1]                         # vowel groups of length at least 2
 p <- function(x){                          # generates all substrings of inputs
  n <- nchar(x)
  start <- 1:n
  stop <- rep(n:1, n)                       # this will generate dups
  substring(x, start, stop)  
 }
 q <- unlist(sapply(s, p))                  # all substrings
 q <- q[nchar(q)>1]                         # all length-2 or more substrings
}  
```
[Answer]
# Perl 5, 53 +1 (-p)
```
/[aeiou]{2,}(?{$h{$&}++})(?!)/g;$_=join$",sort keys%h
```
[Try It Online](https://tio.run/##K0gtyjH9/18/OjE1M780ttpIp1bDvlolo1pFrVZbu1ZTw15RUz/dWiXeNis/M09FSac4v6hEITu1slg14/9/h8rEpNTU1MTKzPz4@NR/@QUlmfl5xf91CwA)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~93~~ 88 bytes
```
param($a)0..($b=$a.count-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}}|?{$_-match'^[aeiou]{2,}$'}
```
[Try it online!](https://tio.run/##DcjRCoMgFADQf4k7UpjS9h77EHFyc4K28oYWezC/3fV4zkY/l7J3y9LahglXBsgHKRlMI6C0dMRdPPh5KwzCCIZLCdMlMVOIgArCFUbXer4KGLHibn3/VugCHbo87xX62lpjynpMSutuCOTigBgox/mbPx3/Aw "PowerShell – Try It Online")
Uses lowercase or uppercase I/O (or a mix!).
Borrows code from my answer on [Exploded Substrings](https://codegolf.stackexchange.com/a/78712/42963) to get all the substrings, then pulls out those that regex `-match` against `^[aeiou]{2,}$` -- i.e., those that are at least two vowels in length and only vowels. Those strings are left on the pipeline and output is implicit.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
Œʒg≠}ʒžMм_
```
[Try it online!](https://tio.run/##ASkA1v8wNWFiMWX//8WSypJn4omgfcqSxb5N0Lxf//9AeWFiZWVlYXlpb19fZQ "05AB1E – Try It Online")
**Explanations:**
```
Œʒg≠}ʒžMм_  
Œ            Push all substrings (abeoic => a, b, e, ..., eoi, eoc, ... abeioc)
 ʒ  }        Filter elements for which result is 1
  g≠            Push 1 if length is != 1, 0 otherwise
     ʒ       Filter elements for which result is 1
      žMм       Remove all occurences of 'aeiou' from element
         _      Negative bool: push 1 if length == 0, 0 otherwise
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~148~~ ~~137~~ ~~130~~ ~~123~~ 118 bytes
*Thanks to @Laikoni for -11 bytes, further -7 bytes by pointing me to golfing tips, another -7 bytes, and yet another -5 bytes, for a total of whopping -30 bytes.*
~~This looked like a good fit for Haskell but the result doesn't seem to agree.~~ I guess Haskell was an OK-ish choice after all. I'm still annoyed by the way `subsequences` works though.
```
import Data.List
v=(`elem`"aeiou")
p s=nub$do x<-groupBy((.v).(&&).v)s;[y|y@(c:_:_)<-subsequences x,v c,y`isInfixOf`x]
```
[Try it online!](https://tio.run/##FY/BaoNAFEX38xWTUIKWZAgt1ZBGCaWbQqAfUBp96tO8RudNHbVO6L9buzrcs7hwLmCvWNfTRI3htpOv0IE6ke3EEHkp1tikS0DifukLI22k@@yuYDkeNlXLvXlxnqcGX3mrlT/TPn@4X3f08n2yT/zDxvaZxe8edY5WjutB5muXkn3TJY3vZTp@Tg2QjirsTqQxjiPTku6UieN/P7VBeD57/n3w9BiEu4fFLhSm5aqFpiFdSdPfbvV8DLqQORcoK65LATBvpZQk@cN6ISBDplw4uMi5gyXUII5utojgiJMExZYY9RaA2Oqvqy3@AA)
[Answer]
# Perl, 45 bytes
```
local $,=" ";print $_=~/(?=([AEIOU]{2,}))/ig;
```
[Answer]
# [R](https://www.r-project.org/), ~~120 bytes~~ 110 bytes
```
function(x){k=nchar(x);i=k:1;e=expand.grid(i,i[-1]);grep("^[aeiou]+$",mapply(substr,x,e[,2],e[,2]+e[,1]),v=T)}
```
[Try it online!](https://tio.run/##bY/BboMwEETv/QrH6sFuDEpSFaIipH5EbwiiDSxkC9iWgRZS9dupq165jHY1b6QZt9bpWk@6HMloMcvvNtXlDZw/E0rb12OCKc4WdBU2jipBirLgmMukcWgFLzJAMlO@f@SqB2u7RQzTdRidmhVm6pT/696rD6nP9F3@rLXgLoqLQsin6OU5is@n3Tnm8sE60qPgQRD4x0PWmcZB35NumJ3u9w4H5ouw0lTIGtPVGxmAv6phyIh9Gb3bIq5oqNwwFrgxP8Yw6GDDflt8EhEWMpcLbgAHMqgPAGQG/dEOFZfrLw "R – Try It Online")
How it works
```
function(x){                  #initalize the anonymous function where input is stored in x
  k=nchar(x)                  #set k to the number of characters in x
  i=k:1                       #create vector of integers from k to 1
  e=expand.grid(i,i[-1])      #create matrix of full outer join on i 
                              #except in the second column, limit i to being less than k
  grep("^[aeiou]+$",          #search for strings made of only vowels
       mapply(substr,         #map the substring function
              x,              #with x as the string to subset
              e[,2],          #start at the second column of the outer join
              e[,2]+e[,1]     #end at the sum of the sum of the first and second columns
       ),
       v=T                    #if a match is found, return it's value
  )
}                             #by default, R returns the last line of a function
```
[Answer]
# C, 119 bytes
```
f(char*s){*s&&f(s+1);char*t,*b=calloc(strlen(s),1);for(t=b;*s==65|*s==69|*s==73|*s==79|*s==85;b[1]&&puts(b))*t++=*s++;}
```
[Try it online!](https://tio.run/##fdBdT4MwFAbg@/2KjgvSlkGcCx@GkFhHnVVGF4gxzLkFiOgSBEPxau63Ix9emeDVm573OeeiqfqWpk2TwfQ9rrBAJyxkOYNCmSO7H9UznDhpnOdlCkVd5a8FFGjWtllZwdpJbCwcx9C/@7jqw1wMMbws3U6e5y@y/PlVC5gghGtFcbBQFPvcHIsafMTHAqLJaQIA6I2kququkJDdTTIoBYa530OEDX1hmNbl1DLbbpC74o/dBHwVkPWa@SuwedxuPRoC4rtgyV0KVty7HV8lpIWapgEGnrg//QfeUM6W431E7gBlnAPikXF1HbV3KCUR44cDHXcXjFO/JITx0L9/CN1OVu2/Zb@2k@fmBw)
[Answer]
# JavaScript (ES6), 105 bytes
```
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
```
Probably has a lot of golfing left to do.
```
let f=
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
console.log(JSON.stringify(f('r67^^()*6536782!87')))
console.log(JSON.stringify(f('programming puzzles and code golf')))
console.log(JSON.stringify(f('aaand... i won!')))
console.log(JSON.stringify(f('abeoic')))
console.log(JSON.stringify(f('yah eioo ala')))
console.log(JSON.stringify(f('@yabeeeayio__e')))
console.log(JSON.stringify(f('0ioen0aaiosnjksd')))
```
[Answer]
# [Perl 5](https://www.perl.org/), 44 + 1 (`-n`) = 45 bytes
```
map{say}/(?=([aeiou]{$.}))/g while$.++<y///c
```
[Try it online!](https://tio.run/##K0gtyjH9/z83saC6OLGyVl/D3lYjOjE1M780tlpFr1ZTUz9doTwjMydVRU9b26ZSX18/@f9/h8rEpNTU1MTKzPz4@NR/@QUlmfl5xf91fU31DAwN/uvmAQA "Perl 5 – Try It Online")
[Answer]
# C, ~~105~~ 75 bytes
A function accepting a pointer to lowercase input, and producing space-separated strings on standard output:
```
i;f(char*p){for(i=strspn(p,"aeiou");i>1;)printf("%.*s ",i--,p);*p&&f(p+1);}
```
### Test program
```
#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char *in = argv[i];
        printf("'%s' -> [ ", in);
        f(in);
        puts("]");
    }
}
```
### Demo
```
'r67^^()*6536782!87' -> [ ]
'programming puzzles and code golf' -> [ ]
'aaand... i won!' -> [ aaa aa aa ]
'abeoic' -> [ eoi eo oi ]
'yah eioo ala' -> [ eioo eio ei ioo io oo ]
'@yabeeeayio__e' -> [ eeea eee ee eea ee ea io ]
'0ioen0aaiosnjksd' -> [ ioe io oe aaio aai aa aio ai io ]
```
### Explanation
```
#include <string.h>
#include <stdio.h>
void find_polyphthongs(char *p)
{
    /* from longest polyphthong substring down to 2 */
    for (int i = strspn(p,"aeiou");  i >= 2;  --i) {
        /* print exactly [p .. p+i] */
        printf("%.*s ", i, p);
    }
    /* tail-recurse to next char */
    if (*p) {
        find_polyphthongs(p+1);
    }
}
```
Using GCC on Debian Linux, I seem to get away with the incompatible implicit declarations of `strchr()` and `printf()`. Other platforms may require `<stdio.h>` and `<string.h>` to be included.
[Try it online](https://tio.run/##XVDbTsMwDH3vV3hFsKRbKgpiQyqb@Ase0EAmTTtDm0RJB9qm/TohHTeBX@LjnGMfW4pGyhCorJlco8ss39fGMVr43nmrmZ2mqMhsUl7Ssii5daT7mqWneeYhnZIQU8vLzJ6d1cxOCl4ewglp2W4qBTe@r8jk62WSJFEFHZJmQ4KukVMY5kGWRfDKk30CMeJoODIIFlCUEN@bIzumkwlx@KQN8akmHYlDh3talT9/3ybHp34MYgn30SmQ5r@Mmv2BdtN7lq7Sr9IhOYTgZvOHB8az2dXlbH59MbqeB@tM47DrSDdRstu1ygPqCqSJ2zamrQNixHmeR@NvRo8CPilDMmxxDfGKBrDFcLuNVaVwS@bxUYVzMkqfI5Lx@vnFV@@ybrHxQcTrLWRRBNGhk@uFxp5eVRB32gjqbEuSehH3/FepN1r2ZLSolGzR4ZB/AA "C (gcc) – Try It Online") (requires Javascript).
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 53 bytes
This is a `Dfn` (**d**irect **f**unctio**n**). Usage is `p '<argument>'`. Fair warning: this is not very efficient and times out for `input > 8 characters` on TIO, but works normally when given enough time.
```
p←{(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@BR24RqDfdHHV2Pupp19B/17NWJedQxA0gfWgFk9ex91LtVU98dqAosX62hUwaU1tN51LVI81HvYqAskFUGlFZPTM3ML1WvPbTiUe/mR52LDB@1TQbK1gKtUE9MSs3PTFYHAA "APL (Dyalog Unicode) – Try It Online")
Thanks to @Adám for 16 bytes!
### How it works:
This is easier to understand if we break the code in smaller portions:
* Part 1 - `G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵`: This part of the function takes the length of the (right) argument and mixes the vector `aeiou` to itself that many times, yielding every possible combination of `[2, length(right arg)]` vowels.
* Part 2 - `(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/`: This part checks which element(s) of G are members of the substrings of the input. This returns a boolean vector, with `1`'s at the indices of the vowel combinations that are present in the input and `0`'s where they're not. The resulting vector is then mapped (`/`) over `G`, returning the elements corresponding to the truthy values.
The whole thing is then assigned to `p`. `p←` is not included in the byte count because it's not *necessary*, it just makes using the function easier.
[Answer]
# [Haskell](https://www.haskell.org/), 74 bytes
```
f[]=[]
f(h:t)=filter(all(`elem`"aeiou"))[h:take i t|i<-[1..length t]]++f t
```
[Try it online!](https://tio.run/##HY5dTsMwEITfOcXWTzalVgGRVKiRuAAnsNx2adbJEv9EiSuUiruHhLeZb0aaaXHsyPt5dsZWxj442b5nVTn2mQaJ3ssLeQoXgcTpJpQyS44dAUP@5ePOPGvtKTa5hWztdusgzwE5QgUB@0@Q/cAxgwanwIihKE8nqR6Lt9eiPLxsDqV4AtEPqRkwBI4N9Lf73dMIGGu4ppqgSd6tJcQFaa2X4Z8UN//oixJfVzVhC8u/BOhx9R/TkhHhxOl8ppXsOVHcI3Ia43c31sLOfw "Haskell – Try It Online")
[Answer]
# Ruby 2.4, 100 bytes
```
(2..(b=(a=gets).size-1)).to_a.flat_map{|i|(0..(b-i)).to_a.map{|j|a[j,i]}}.select{|k|k=~/^[aeiou]+$/}
```
This is my first attempt at golfing, and I'm sure there are lots of ways to shorten this code.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 80 bytes
```
->s{[*0..z=s.size-2].product([*2..z]).map{|v|s[*v][/[aeiou]{2,}/]}.uniq.compact}
```
[Try it online!](https://tio.run/##fZLLcuJADEX3fIVSszBQTociFciG1HzE7FxOSrQF1mC3PO42xDy@nbQfJMwkGS/kUl/dI/WjrJb1ebU43z7ZQzSeKLVfWGV5T7fTWBWlJJV2w2g89UI8UjkWh@P2aKPxNo7uIiSWKj5Mw9NdfFKV4T9KS16gdqfzYQAQlLP58/NwNJ493M/mj9Obx3kA/3yLJ4jisCn23dYl5jmbNRTVfp@RBTQJaEkI1pKtgqtiRC8ppYBhJ@bmE7Yn@7oghPeIQe9ekrD@yvS3m6TxCTfRO3p3jSn4nQtghsH/3K2PO0YbqUv4PZMe@bP2IxFhzfLyQsH3SGqNXcQPPF0E7LPLTicsZCaILNb83tgk@AbcT0lXp3U1PV8E7hTps3b800AR6hQSgeMm3B592wJW0SYekEkGP@BXSrCqjHYsBkrKZesvNqmKjDU6siFYAXaQYw1Gmr/zMHr1ryirYccuBecJ9FqQdpR4gq0yZ2FYGf9CbCte1rqiKzg4gSX1XZMQ2MAuZc/XaKnpuuMsG6nzGw "Ruby – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 15 bytes
```
f&tT!-T"aeoi".:
```
[Try it online!](https://tio.run/##K6gsyfj/P02tJERRN0QpMTU/U0nP6v9/pcrEDIXUzPx8hcScRCUA "Pyth – Try It Online")
Definitely golfable, I want to get it better before writing out explanation.
---
[Answer]
# T-SQL (SQL Server 2014), 281 bytes
```
;with s as(select substring(@,1,1)C,stuff(@,1,1,'')D,1 R union all select substring(D,1,1),stuff(D,1,1,''),R+1from s where len(D)>0),c as(select R i,C w from s where C LIKE'[aeiou]'union all select R,w+C from c join s ON i+1=R where s.C LIKE'[aeiou]')select w from c where len(w)>1
```
Input give by
```
declare @ varchar(max) = 'abeoic'
```
Uses a common table expression `s` to blow the input apart into ordered individual letters, and then a second common table expression `c` to generate all ordered combinations, throwing out non vowels.
[SQL Fiddle](http://sqlfiddle.com/#!6/9eecb7db59d16c80417c72d1e1f4fbf1/11226)
[Answer]
# PHP, 139 bytes
```
function y($s){$p=[];$l=strlen($s);for($i=2;$i<=$l;$i++)for($j=0;$j<=$l-$i;$j++)strspn($a=substr($s,$j,$i),'aeiou')==$i&&$p[]=$a;return$p;}
```
[Online demo](http://sandbox.onlinephpfunctions.com/code/c66cbf34f38a032ecb4b4cd355d79c550afdcd80)
```
function yreadable($s)
{
    $p = [];
    $l = strlen($s);
    for($i=2; $i<=$l; $i++)
        for($j=0; $j<=$l-$i; $j++)
            strspn($a=substr($s,$j,$i),'aeiou')==$i
            && $p[] = $a;
    return $p;
}
```
## How it works
Select sub-strings (beginning with the length of 2) consisting of adjacent characters and move along string.
Collect any sub-strings that only contain vowels. Repeat with longer sub-strings.
For string 'abcdef' these are the substrings generated and checked:
```
'ab','bc','cd','de','ef'
'abc','bcd','cde','def'
'abcd','bcde','cdef'
'abcde','bcdef',
'abcdef'
```
[Answer]
# [Vyxal 2.6.0pre1](https://github.com/Vyxal/Vyxal/releases/tag/v2.6.0pre1) , 6 bytes
```
K~Ḣ'AA
```
No TIO link yet.
```
K      # Substrings
 ~Ḣ    # Filtered by a[:1] exists (len(a) > 1)
   '   # Filtered by...
     A # All...
    A  # Are vowels.
```
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 bytes
```
K'Ḣ;'kv↔=
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=K%27%E1%B8%A2%3B%27kv%E2%86%94%3D&inputs=abeoic&header=&footer=)
```
K         # Substrings
 ' ;      # Filtered by...
  Ḣ       # a[1:] is nonempty
    '     # Filter again by...
       ↔  # Removing everything but...
     kv   # Vowels
        = # Leaves it identical to the original.
```
]