[Question]
  [
In an [earlier challenge](https://codegolf.stackexchange.com/questions/188988/ddoouubbllee-ssppeeaakk) I asked code golfers to produce strings which copy each character in a string. For example:
```
TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!
```
This challenge is simply to detect if some text meets the definition of a double speak string.
* There is an even number of characters.
* When split into pairs, every pair consists of two of the same character.
---
The challenge
* It's code golf, do it in few bytes.
* Use any language you choose.
* Please include a link to an online interpreter.
* The code will accept some text.
* For simplicity, the input will only consist of *printable ASCII characters*
* It will return an indication of whether or not the input is double speak. It could be:
* A boolean
* Strings ('true', 'false', 'yes', 'no' etc)
* Integers 0 or 1
---
Test Cases:
```
input -> output
aba -> false
aab -> false
abba -> false
aabb -> true
aaabb -> false
tthhiiss -> true
ttthhhiiisss -> false
```
  
[Answer]
# [Python 3](https://docs.python.org/3/), 24 bytes
```
lambda s:s[::2]==s[1::2]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYqjjaysoo1ta2ONoQxPhfUJSZV6KRpqEUEpKRkZlZXKygACFTUvLzS0uTknJyUlMVFIqLCwpSUxMTs7MVFZU0NbkQ2jIyixUyi/PUS4DC/wE "Python 3 – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 20 bytes
*Saved 1 byte thanks to Jo King.*
```
+>,[>,[-<->]<[<],]<.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9f204nGoh0bXTtYm2ibWJ1Ym30/v8PCcnIyMwsLlZQgJApKfn5paVJSTk5qakKCsXFBQWpqYmJ2dmKigA "brainfuck – Try It Online")
[Readable output!](https://tio.run/##SypKzMxLK03O/v9f204nGoh0bXTtYm2ibWJ1YnWjdUHARhsoAKT1/v8PCcnIyMwsLlZQgJApKfn5paVJSTk5qakKCsXFBQWpqYmJ2dmKigA "brainfuck – Try It Online")
Takes input two characters at a time, and moves away from the 1 on the tape if any pair doesn't match. EOF is treated as 0 and thus handled automatically.
Output is a null byte if the string is not double speak, and 0x01 if it is. The readable version outputs these as characters at a cost of 14 bytes.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 4 bytes
```
Heda
```
Input is a string, enclosed with single qoutes. Output is `0` for double speak, `1` otherwise.
[Try it online!](https://tio.run/##y00syfn/3yM1JfH/f/WQkIyMzMziYgUFCJmSkp9fWpqUlJOTmqqgUFxcUJCampiYna2oqA4A)
### Explanation
Consider input `'TThhiiss iiss ddoouubbllee ssppeeaakk!!'` as an example.
```
H    % Push 2
     % STACK: 2
     % Implicit input (triggered because the next function requires two inputs): string 
     % STACK: 'TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!', 2
e    % Reshape as a 2-column matrix of chars, in column-major order. Pads with char(0)
     % if needed. Note that char(0) cannot be present in the input
     % STACK: ['This is double speak!';
               'This is double speak!']
d    % Difference of each column
     % STACK: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
a    % Any: gives 0 if and only if all elements are 0
     % STACK: 0
     % Implicit display
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~6~~ ~~5~~ 2 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ιË
```
Input as a list of characters.
-3 bytes by porting [@Shaggy's Japt answer](https://codegolf.stackexchange.com/a/189372/52210), so make sure to upvote him!
[Try it online](https://tio.run/##yy9OTMpM/f//3M7D3f//RyuFKOmAcQYUZ0JxMRQrQDEu8RQozofiUihOguIcKE6FYpg@mDkFUAyTT4TibChWBONYAA) or [verify a few more test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn1l8P9zOw93/9f5HxKSkZGZWVysoAAhU1Ly80tLk5JyclJTFRSKiwsKUlMTE7OzFRW5iFbKRYKZqcUlXD45@fnl5ampRUXJyYmJxcWpqVzOzvn5RUWpqcnJJSUKClZWmppcJUCQmlpcXFKiCNSYCAcA).
**Explanation:**
```
ι   # Uninterleave the (implicit) input-list of characters
    #  i.e. ["t","t","t","t","e","e","s","s","t","t","!","!","!"]
    #   → [["t","t","e","s","t","!","!"],["t","t","e","s","t","!"]]
 Ë  # Check if both inner lists are equal
    #  → 0 (falsey)
    # (after which the result is output implicitly)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 4 bytes
```
ó r¶
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8yBytg&input=IlRUaGhpaXNzICBpaXNzICBkZG9vdXViYmxsZWUgIHNzcHBlZWFha2shISI)
```
ó r¶     :Implicit input of string
ó        :Uniterleave
  r      :Reduce by
   ¶     :  Testing equality
```
## Alternative
```
ó
¥o
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8wqlbw&input=IlRUaGhpaXNzICBpaXNzICBkZG9vdXViYmxsZWUgIHNzcHBlZWFha2shISI)
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
■◄┼$Δ
```
[Run and debug it](https://staxlang.xyz/#p=fe11c524ff&i=TThhiiss++iiss++ddoouubbllee++ssppeeaakk%21%21%0Aaaaa%0Aaaa%0AThis+is+just+regular+speak.%0Aaabbc&a=1&m=2)
**Procedure:**
* Calculate run-lengths.
* Get GCD of array.
* Is even?
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 9 bytes
```
(.)\1
^$
```
[Try it online.](https://tio.run/##lYyxCsJAEAX7/Yo9UMg1Qtq0KWwsU4q4uTzIkcMLtxvy@WdAsNYpXjVvCiy@pK3n5vqszcXfW6LHqdZhmOcYVZk/O005b9s4pgQwq64rILIsztHPKv3RhBrdUs77DpQSgogqQH2fcylACGbMXec92QGgauaOo3x5Aw)
**Explanation:**
Remove all pair of the same characters:
```
(.)\1
```
Check if there are no characters left:
```
^$
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
ŒœE
```
[Try it online!](https://tio.run/##y0rNyan8///opKOTXf///x8SkpGRmVlcrKAAIVNS8vNLS5OScnJSUxUUiosLClJTExOzsxUVAQ "Jelly – Try It Online")
[Answer]
# JavaScript, 28 bytes
```
s=>s.every((x,y)=>x==s[y|1])
```
[Try it online!](https://tio.run/##bcxBCoMwEEDRfU8RXSXQDvQA8RTuxMXEjDU1OMGpYqB3TxG33fzNg//GHWVYQ/o8FvZURlvENgK005q1Pu7Z2OawVrr8ffamDLwIR4LILz3qDgDqtp2mEESUuuo987Y5FyORUiIpESHOc1XVvTG3Pwd0Dk8rPw "JavaScript (Node.js) – Try It Online")
---
**23 bytes** using wastl's regex
```
s=>/^((.)\2)*$/.test(s)
```
[Try it online!](https://tio.run/##XcuxCoMwEIDh3aeI0uGu0Aju@hSOpXAxZ40GL/Sirx8L3br8wwf/Sifp9AkpP3bxXOa@aD@0LwCLzw7vt9Zm1gyKZZJdJbKN8oYZmnFclhBUjfnVe5HjcC5GZmNUU2Im2ra6bhCrv5mcoy@XCw "JavaScript (Node.js) – Try It Online")
[Answer]
# x86 machine code, ~~9~~ 8 bytes
```
D1 E9       SHR  CX, 1          ; divide length in half
       L1:
AD          LODSW               ; load next two chars into AH/AL 
3A E0       CMP  AH, AL         ; compare AH and AL 
E1 FB       LOOPE L1            ; if equal, continue loop
C3          RET                 ; return to caller
```
Callable function. Input string in `SI`, input string length in `CX`. Output `ZF` if is double speak.
### Or *14 bytes* as a complete PC DOS executable:
```
B4 01       MOV  AH, 01H        ; DOS read char from STDIN (with echo) 
CD 21       INT  21H            ; read first char into AL
92          XCHG DX, AX         ; put first char into DL
B4 08       MOV  AH, 08H        ; DOS read char from STDIN (no echo) 
CD 21       INT  21H            ; read second char into AL
3A C2       CMP  AL, DL         ; compare first and second char 
74 F3       JE   -13            ; if the same, continue loop 
C3          RET                 ; otherwise exit to DOS 
```
Input is via `STDIN`, either pipe or interactive. Will echo the "de-doubled" input until a non-doubled character is detected, at which point will exit (maybe bending I/O rules a little bit, but this is just a bonus answer).
[![enter image description here](https://i.stack.imgur.com/ZShOq.png)](https://i.stack.imgur.com/ZShOq.png)
Build and test ISDBL2.COM using `xxd -r`:
```
00000000: b401 cd21 92b4 08cd 213a c274 f3c3       ...!....!:.t..
```
### Original *24 bytes* complete PC DOS executable:
```
D1 EE       SHR  SI, 1          ; SI to DOS PSP (080H) 
AD          LODSW               ; load string length into AL 
D0 E8       SHR  AL, 1          ; divide length in half 
8A C8       MOV  CL, AL         ; put string length into BL 
        CLOOP: 
AD          LODSW               ; load next two chars into AH/AL 
3A E0       CMP  AH, AL         ; compare AH and AL 
E1 FB       LOOPE CLOOP         ; if equal, continue loop
        DONE: 
B8 0E59     MOV  AX, 0E59H      ; BIOS tty function in AH, 'Y' in AL 
74 02       JZ   DISP           ; if ZF, result was valid double 
B0 4E       MOV  AL, 'N'        ; if not, change output char to N 
        DISP: 
B4 0E       MOV  AH, 0EH 
CD 10       INT  10H 
C3          RET                 ; return to DOS
```
Input from command line, output to screen `'Y'` if double, `'N'` if not.
[![enter image description here](https://i.stack.imgur.com/1NFTK.png)](https://i.stack.imgur.com/1NFTK.png)
Build and test ISDBL.COM using `xxd -r`:
```
00000000: d1ee add0 e88a c8ad 3ae0 e1fb b859 0e74  ........:....Y.t
00000010: 02b0 4eb4 0ecd 10c3                      ..N.....
```
### Credits:
* **-2 bytes** thx to @ErikF!
[Answer]
# [Malbolge (*unlimited memory access variant*)](https://esolangs.org/wiki/Malbolge_Unshackled), Around 4 megabytes
You asked the golfers, but for the second time forgot about the bowlers.
This is too big to include in the answer for obvious reason so here is gist [link](https://gist.githubusercontent.com/kspalaiologos/a02e57046360ec5f1265ec25ce26768b/raw/8d1bd1b4b705f227c2c76de9921205a7531704de/189358).
You might want to use the fast interpreter to test this program, as it's hellishly slow (hellishly, get it?). I'm going to include the TIO.run link after Dennis (hopefully) takes on my issue on TIO tracker.
// Edit: Nope, no TIO link as the answer size limit is 65536 bytes, and no abusing url shorteners because they just refuse to shorten it
[Answer]
# [PHP](https://php.net/), ~~58~~ 56 bytes
```
function f($s){return!$s?:$s[0]==$s[1]&f(substr($s,2));}
```
[Try it online!](https://tio.run/##hZCxboNADIbn3FMYhApIVKEdm6JsfYJsCYMhJqCgu9PZN0V59dK7UKlL1S72/8v2Z9l2tMv73oY4eN3LZDQMRcblzZF4p5OM928ZH@u2aUJ6aZ@Ggn3H4kJT9VqWu/uSCbEwNHBUCrZbEOdJQX44jOM0MQOs8Xw2xvuum2ciAGZriRCv1yTJq80mDIgQieRVkIiPVNeIdR3kgzvgzL@AtZE/2RDZ2HUrcl0iPzqqUI9LWrVTivrRQIbuoitIT5JW8R/RltHrk05D02AcYT8W8H078joCJdwC7h9GINwXEWaRT2Pjz3l5/vgC "PHP – Try It Online")
As a recursive function.
# [PHP](https://php.net/), ~~61~~ ~~56~~ 52 bytes
```
while(''<$l=$argn[$i++])$r|=$l!=$argn[$i++];echo!$r;
```
[Try it online!](https://tio.run/##hZHBbsMgDIbP5SmcCCmpmqk5L4122xP01vbgtE5BjQABUQ9bX30ZhGmdpqm7YGPwZ/4fI8y0eTHCMLZew9WiAakAoR/V0UutoNcWCJ0kC56cl@r8zO6HJUd7Vkt4m65CDlQWxYYP7VzccblaHZbcvrd8yH7WGjoKnXHbTDfGeKQ6aGHHGIQneDsSg2K7FUJK5wDSejppPY5dNwxEAM4ZQ4R4uWRZUS0WocF7Iu@LKqSIc6hrxLoOaQL3OLg/yEr7h3CIcOy6xExT/D2PWThPYR52YA1jUSHMkivI9z6vvq2Ke7VXebgUrCU8ihK@PECXWiD4GXD/MALhNv22Kap5IOdDm/hvbnp6/QQ "PHP – Try It Online")
Or standalone program. Input string via `STDIN`, output is `truthy` (`1`) if it is double speak, and `falsey` (`0`) if it is not double speak. 
-4 bytes thx to [@Night2](https://codegolf.stackexchange.com/users/81663/night2)!
[Answer]
# [Haskell](https://www.haskell.org/), ~~28~~ 23 bytes
```
f(x:y:z)|x==y=f z
f[]=1
```
[Try it online!](https://tio.run/##bYyxDsIwDET3foUbMcDIWilbZ34AMcRtIqo4dYVTqa3492BWwo3v3t3TSfREpYTz1u3dcXlv1u42wNGE@8NeS3LTDBZGbkCzvKY5wwkCmL5nXldEIu8BRJbFe@dibFvzq96YOWf9UF19HWjGSnOIroZKEf9gopSYRXLOVSvCDDAMRF/Dm/IB)
Very straightforward. Double speak is only empty or a repeated character prepended to double speak.
Less straightforward now. Outputs via presence or absence of an error, per [meta consensus](https://codegolf.meta.stackexchange.com/a/11908/73884); no error means double speak. Pattern matching fails when the first two characters differ or when there are an odd number of characters. Thanks to [Laikoni](https://codegolf.stackexchange.com/users/56433/laikoni) for these savings!
[Answer]
# [Lua](https://www.lua.org), ~~67~~ ~~66~~ ~~63~~ ~~59~~ ~~33~~ 32 bytes
-25 bytes thanks to Giuseppe  
-1 byte thanks to val
```
print(#(...):gsub("(.)%1","")<1)
```
[Try it online!](https://tio.run/##yylN/P@/oCgzr0RDWUNPT0/TKr24NElDSUNPU9VQSUdJSdPGUPP///@JiUlJiYkA "Lua – Try It Online")
Removes every doubled character, then checks if the result is empty.
[Answer]
# [Perl 5](https://www.perl.org/), 15 bytes
```
$_=/^((.)\2)*$/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lY/TkNDTzPGSFNLRf///5CQjIzMzOJiBQUImZKSn19ampSUk5OaqqBQXFxQkJqamJidraj4L7@gJDM/r/i/bgEA "Perl 5 – Try It Online")
Outputs 1 for double-speak, nothing for non-double-speak.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 2 bytes
```
½=
```
[Try it online!](https://tio.run/##y00syUjPz0n7///QXtv//9VLUotL1LnUS0pSU4uLS0DMjIzU1Jyc/HwdBYXy8vz8oqKcnJQURUWgjEcGkADRHlAV6EoA "MathGolf – Try It Online")
Basically the same as the 05AB1E answer, `½` splits the string into even and odd characters, then check for equality. Passes for the empty string.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~39~~ 38 bytes
```
!$($args|?{+$p*($p="$_"[$p-eq$_])};$p)
```
[Try it online!](https://tio.run/##bZHBTsMwDIbvfQp3GNbCeIKpohJC2g0kequqKd3ctSwsWZwAUtdnL2FdD9vIIYr@z/lsyVp9k@GapOyxSto@xAiF2fDhqX1AfR@hTia4nOSoH2mPyyLu5qjjvguCNArAn1mE1jiaAUwXC/IepabxSCoh2aOR/APO49GUZXXdNMwAw71eK@VcWUpJBMCsNZEQ220Y@r@XTlGW4lopfHzdP8uI2NrL8iEfQBAfbtsjRvrRtLK0ngEyJIDLITbETlof3GEFqR/3BtiaZrcB1lJY618h0N41X0LSzkKlDOSrWpi8KI6G/O392bFVn6/lh29QpO2gTE7qOTT8cuo9Zn/rGOfxfKedL@cu6Pr@Fw "PowerShell – Try It Online")
where `$p` contains a previous char.
No [recursion](https://codegolf.stackexchange.com/a/189404/80745), no [regex](https://codegolf.stackexchange.com/a/189370/80745) :). Takes input as a char-array via a splatting string (see TIO link).
---
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 48 bytes
```
for(;$b-eq$a-and$args){$a,$b,$args=$args}$b-eq$a
```
[Try it online!](https://tio.run/##bZFNasMwEIX3PsWEqo0DzgmCwVAK2bVQ70Ioo3gcu1EtRSO1Bddnd1X/LJpEi0F63@i9QTL6iyxXpFQvyrTtS23jjZBrOgtcY1MItEdetQITIZPhkA61m3r6LoqyOIKwklg46ykBWG63FBy1Xq5mUqLigGZyA/yXZ6c8r6q6ZgYYa1Fo7b2UShEBMBtDhHg6LRbh7qUnSonXlhjk6/w8J2LnLttHfQTR6ue@HbCgb0MHR0UCgiEF8TbKltgrF4QHUUIWxr0DdrZujsBGoXNhtwA6@/oTFTUOwmvD7lCh3e33g8Pu5fXRs9Mfz/I9BOyzdrRMJ@sN1Pw0Zc/a3z/M8wTeGB/auYu6vv8F "PowerShell – Try It Online")
No [recursion](https://codegolf.stackexchange.com/a/189404/80745), no [regex](https://codegolf.stackexchange.com/a/189370/80745) and no pipe :D. It also takes input as a char-array via a splatting string. It uses `$b-eq$a` instead `$a-eq$b` for a case when a last char has #0 code.
[Answer]
# [Shakespeare Programming Language](https://github.com/TryItOnline/spl), ~~204~~ 156 bytes
-48 bytes thanks to Jo King (mostly by changing the output method)
```
A.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck]Ajax:Open mind.Puck:Open
mind.Is I worse zero?If soSpeak thy.Is you as big as I?If soLet usAct I.
```
[Try it online!](https://tio.run/##TY5BCsIwFESvMgcoOUA3kkUXAUGhy9JFTL9aq0nI/8HWy0dSN65mhnkMw/FZilb6YddGnbNbGqWdwLSqd@SpmqFbKXsZh84LJVQU1k@o9FhTe4rk8Zr9tC/8RcMweIfEhA@lcDBXcOgj2QVy32q9hQzLuMy3KuZHHEmQef@hShEh@gI "Shakespeare Programming Language – Try It Online")
Exits with error if the input is double speak, and with warning if it is not double speak (which is [allowed](https://codegolf.meta.stackexchange.com/a/5330/86301) by default).
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~6~~ 4 bytes
*-2 bytes thanks to Razetime!*
```
ETC2
```
[Try it online!](https://tio.run/##yygtzv7/3zXE2ej///9KJSUZGZlKAA "Husk – Try It Online")
Hooray for all ASCII solutions! Outputs a positive number if the input is doublespeak, otherwise zero.
```
  C2  Cut list into chunks of 2
 T    Transpose
E     Check if list has all the same elements (return length of list if so)
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
y=
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=y%3D&inputs=HHeelllloo&header=&footer=)
Look ma, no Unicode!
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 7 bytes
```
Óˆ±
ø^$
```
[Try it online!](https://tio.run/##K/v///DkQx2HNnId3hGn8v9/RkZqak5Ofj4A "V (vim) – Try It Online") or [Verify test cases](https://tio.run/##K/v//3Df4cmHOg5t5AIydsSp/P@fkZGampOTn89VXp6fX1SUk5OSwmVoaGRkbGxiYmrKlZ5eVJQKBHl5Cgrp6Tk5iYnFQKCgkJKSnw9Sz8XlATPA0MjYBKaVKwNmLgA)
Hexdump:
```
00000000: d388 b10a d85e 24                        .....^$
```
Just two regexes. Explanation:
```
Ó   " Remove all occurrences...
 ˆ  "   Any character
  ± "   Followed by itself
    "   This regex is actually just the compressed form of (.)\1
ø   " Count the number of matches
 ^$ "   An empty line
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
ġ₂z₂=
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU/WU9B51rFBKS8wpBrJrH@7qrH24dcL/IwsfNTVVAbHt///RSiEhGRmZmcXFCgoQMiUlP7@0NCkpJyc1VUGhuLigIDU1MTE7W1FRSUcpFQigFIj28EhNzcnJz9fRUVAID8/PLyrKyUlJAUpArYwFAA "Brachylog – Try It Online")
Succeeds or fails.
```
ġ₂       The at-most-length-2 chunks of the input,
  z₂     which have equal length, zipped together,
    =    are equal.
```
[Answer]
# [INTERCAL](http://www.catb.org/~esr/intercal/), 192 bytes
```
PLEASE,1<-#2DOCOMEFROM(2)DOWRITEIN,1DO.5<-#1$',1SUB#1'~#256PLEASE(1)NEXTDOREADOUT#1DOGIVEUP(1)DO(1002)NEXTDO.5<-#1$',1SUB#2'~,1SUB#2DO(3)NEXTDOREADOUT#0PLEASEGIVEUP(3)DO(1002)NEXT(2)DOFORGET#2
```
[Try it online!](https://tio.run/##XY7BCoJAFEV/RZlABQtnxFZtrBlFSJ/oWG01BxQlJXPrr0@SbmxzeXDPO9z69RHvZ95KGV@ZmzITn/aIULhAyLwEQp0YFO5JwFkQmZjCwZl7vNNMnGZnhLUJEee4vOrYiNiDU0iYSyHjaMb94MayeG4o6NiyyEpsLUSb1mOm7D@JtchXkb0R/cZ5kPiMIyIl51VV18OgKEuWZdeNY1G0rRCKMgx9L0SeN42qfgE "INTERCAL – Try It Online")
Output is done with INTERCAL's native "butchered Roman numerals", so the true output of 1 prints as `\nI\n`, and the false output of 0 prints as `_\n\n`.
I don't feel like writing out a full explanation at the moment, but the ungolfed code is [here](https://tio.run/##y8wrSS1KTsz5/z/Ax9Ux2FVBx1DBRldB2YjLxV/B2d/XVcEtyN9XQcNIEyQQHuQZ4qrg6QdUBeLqmYLVGqqo6xgGhzopG6rXKRuZmnFBjdIw1FTwc40IASkNcnV0UfAPDQGqBnHdPcNcFUIDuEBKgFwNQwMDI4RidHON1OugDJCshjE2Yw1gtsKNNsYwGugLkJCbf5C7K1CL0f//jo5OIAAA), I lifted the control flow from [something I wrote earlier](https://codegolf.stackexchange.com/a/181789/85334), and the gist of what it does is read two characters at a time from the input through the usually unhelpful "Turing Tape" I/O until either the first resulting number is 256 (in which case the entire input has been validated and has even length, so it is double-speak), or the second resulting number is not 0 (in which case the second character is different from the first or does not exist, and the input is not double-speak).
I think I might be able to restructure this to cut down on redundancy, but I'm not quite feeling up to that at the moment either.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~64~~ 59 bytes
```
filter f($n){$a,$b,$r=$n;$a-eq$b-and$(if($r){f $r}else{1})}
```
[Try it online!](https://tio.run/##bcmxCoMwEAbgvU8R5B8S0KFz6Vu4icOlvaAQ0vYS6BDy7Kcdla7f9359WfLCMaqGNRYWEyySq6AevofckW6ggT/wA6Un7Lq/uBoMpHHMXK/NNQ3GTo@FZJrnjrynzl0OtNuJxpE551L@8U9VNw "PowerShell – Try It Online")
Recursive function, no regex. Takes input as a `char`-array (see TIO link). Peels off the first two elements into `$a` and `$b`, stores the remaining into `$r`. If we still have elements remaining, recurse along with `$a -eq $b`. Otherwise just check whether `$a -eq $b`. Output is implicit.
*-5 bytes thanks to mazzy*
[Answer]
# [Julia 1.0](http://julialang.org/), 25 bytes
```
s->s[1:2:end]==s[2:2:end]
```
[Try it online!](https://tio.run/##yyrNyUw0rPifZvu/WNeuONrQysgqNS8l1ta2ONoIyv5fUJSZV5KTp5GmoRQSkpGRmVlcrKAAIVNS8vNLS5OScnJSUxUUiosLClJTExOzsxUVlTQ1uYjXiKLvPwA "Julia 1.0 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~13~~ ~~11~~ 10 bytes
```
-:2#_2{.\]
```
[Try it online!](https://tio.run/##RUy9CsIwGNz7FFcdgtAG6RhwsdBJHLSjIkn6lcYWUvyayYePQaEe3MFxP8@4kaLHQUGgwB4qsZSoL6cmlqraPqq3vN3jLjsfJa7BWmLOyA4ePUTbDoNzzMBPu877EIyZJiKAeZ6JtB7HPBfrZkmgdLIsIvueNtpN4UVrQWtj7NovlND/cYqSix8 "J – Try It Online")
*-2 bytes thanks to Adám*
*-1 byte thanks to miles*
TLDR explanation: Is the input the same as every other character of the input doubled?
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~27~~ ~~26~~ 24 bytes
```
2==GCD@@Length/@Split@#&
```
[Try it online!](https://tio.run/##NYuxCsIwFEX3fkVMoZNScK8@qCCCg2A3cXhJXk1o2obmdRK/PUqLdzjnLLdHttQjO42prdK@qs71CeBKw4ttCffgHUNepNvkBn7ku0MLtcUJNdMUIX8WJbwz2TTWOhejECuNGcd5Vsp7IiFiDIEIses2G7nNJKL6bSmlcLVWeqlLFI6FGWflScRA2B3/F62NzD7pCw "Wolfram Language (Mathematica) – Try It Online")
```
        Length/@Split@#&    (*for the lengths of runs of characters*)
2==GCD@@                    (*check that they are all even*)
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), ~~19~~ 17 characters
```
?{!1<|=[|0.(_)]}1
```
Explanation:
```
?             # read input
{             # while
    !1<       # stack length greater than 1?
|             # end of while condition and beginning of while block
    =         # compare the 2 top values in the stack
    [         # if (the condition is the top of stack)
    |         # end of then block and beginning of else block
        0.    # output 0
        (_)   # clear stack (discard top of stack in for loop stack length times)
    ]         # end if
}             # end while
1             # stack is already empty, push a truthy value
              # implicitly output the stack content if there was no explicit output
```
[Try it online!](https://tio.run/##y05N///fvlrR0KbGNrrGQE8jXjO21vD//5CQjIzMzOJiBQUImZKSn19ampSUk5OaqqBQXFxQkJqamJidragIAA "Keg – Try It Online")
[Answer]
# Curry, 18 bytes
*Tested to work in both [PAKCS](https://www.informatik.uni-kiel.de/%7Epakcs/) and [KiCS2](https://www-ps.informatik.uni-kiel.de/kics2/)*
```
f(a:a:x)=f x
f[]=1
```
[Try it online!](https://tio.run/##HcixDkAwFAXQ3VdcYmAgsTbpZjGxi@HhNZEWTatJfX0lzni24NzbWNKbT0lVJEjEWirETM2L7NJJxwUhMDk2Yed2GFHV2b8S1h3XgxIKRd/fdwjragwz4L21zERa53mRPg "Curry (PAKCS) – Try It Online")
[Test it on smap!](https://smap.informatik.uni-kiel.de/smap.cgi?browser/78)
This returns `1` if string is double speak and nothing otherwise.
## Explanation
This is a pretty straight forward translation of the Haskell program:
```
f(a:b:x)|a==b=f x
f[]=1
```
But it uses Curry's more powerful pattern matches to save a bunch of bytes. And while missing a pattern in Haskell is rather difficult to recover from, making this definitely pretty un-idiomatic at best and perhaps a little cheaty. In curry missing patterns just mean it's not a match which is idiomatic and recoverable. So it's shorter and I don't feel like I'm cheating.
## Testing
TIO has a limited ability to test things like this. I recommend you use the [smap link](https://smap.informatik.uni-kiel.de/smap.cgi?browser/78) to test this.
This test handler I've made on smap will not work in KiCS2 or the newer version of PAKCS so you must select `PAKCS 2.2.0` (both `/one-value` and `/all-values` work fine). This is because of the library `Control.SetFunctions` which I use for the test. But the function itself does work in the versions if you want to manually test it.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 14 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 1.75 bytes
```
y=
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyI9fiIsIiIsInk9IiwiIiwiISguKikgLT4gKFxcZClcbmFiYSAtPiAwXG5hYmJhIC0+IDBcbmFhYmIgLT4gMVxuYWFhYmIgLT4gMFxudHRoaGlpc3MgLT4gMVxudHR0aGhoaWlpc3NzIC0+IDAiXQ==)
Basically every other answer
## Explained
```
y=
y   # Uninterleave the input, dumping to stack
 =  # Are the two items equal?
```
]