Given an infix expression, determine whether all constants are of the same type.

Operators will consist only of these dyadic operators: +-/*

Your program or function should take a valid expression string as input, and output a truthy value if the constants in the expression are of the same time, and a falsey value otherwise.

The expression will consist solely of constants, and may contain any of the following types:

• String, of the form "String" (Always double quotes, can be empty, no escape characters, may contain any ASCII text)


• Integer, of the form 14 (Always positive or zero)


• Float, of the form 7.3f (Always positive or zero, always has a decimal component, eg 14.0f)


• Byte, of the form 0x42 (0-255, Always 2 hexadecimal characters)


• Boolean, of the form true (true or false, case insensitive)

The expression will not contain parentheses, as order of operation doesn't affect type when no type coercion is present.

A lone constant with no operators is a valid expression.

An empty expression is not a valid expression.

You may assume that the expression string contains no whitespace outside of string literals.
Note: Alternatively you may assume that there will always be spaces between constants and operators, as seen in the testcases. If you make this assumption, please specify as such in your answer

You do not have to handle invalid expressions such as 1 +.

Scoring

This is code-golf, so fewest bytes wins!

Test cases

(Whitespace added for readability)

2 + 3
True

"Hello" / "World"
True

true * false
True

"Hello" + 4
False

"Hello" + "4"
True

3 + 2.4f / 8
False

0xff * 0xff
True

0xff + 2
False

6
True

" " + ""
True

"4 + false" + "word"
True

05AB1E, 50 24 bytes

'"¡āÉÏ»lð¡āÉÏε".e
x"Så}Ë

-26 bytes by making a port of @NickKennedy's Jelly answer, so make sure to upvote him!!

Expects input with spaces at the operands.

Try it online or verify all (plus some more) test cases.

Explanation:

'"¡ '# Split the (implicit) input-string by '"'
 āÉÏ # Only keep all values at 0-based even indices
 » # Join them by newlines
 l # Converted to lowercase (for `true`/`false`)
ð¡ # Split by spaces (NOTE: `#` cannot be used here, since inputs without
 # operands wouldn't be wrapped inside a list)
 āÉÏ # Keep all values at 0-based even indices again
 ε".e
 x"Så} # Check for each item for each of [".","e","n","x"] if it's in the item
 Ë # Check if all inner lists are the same
 # (which is output implicitly as result)

Python 2, 102 bytes

import re
def f(s):
	m=map(eval,re.split('[*+-/]',s))
	return all(map(lambda t:type(t)==type(m[0]),m))

Try it online!

Not entirely sure how to represent some of these types in Python. For example, 0xff and 2 are both treated as integers. And 2.4f isn't a valid type in Python, I think. Capitalized True and False for testing Booleans.

Edit: Grammar

Stax, 26 bytes

ïd"┬Z¡►L!8$lm╗╕╤☻ú≡╝ò6Å>^

Run and debug it

This program expects spaces around the operators. In general, it works by applying a few transformations to the input such that the maximum character for each expression type is distinct.

Unpacked, ungolfed, and commented, it looks like this.

i suppress automatic evaluation of input
'"/2::'s* replace quoted strings with 's'
.d'9R replace all digits with '9'
.ez|t replace 'e' with 'z'
j2:: split on spaces, and discard alternating groups (operators)
{|Mm calculate the maximum character in each remaining group
:u resulting array contains exactly one distinct value

Run this one

Japt -!, 36 bytes

`".*?" 0x.. %S+f %d e|E`¸è@UÀ(U=rXÃÉ

Try it