Idiomatically determine all the characters that can be used for symbols: Difference between revisions

{{task}}

Idiomatically determine all the characters that can be used for ''symbols''.

The word ''symbols'' is meant things like names of variables, procedures (i.e., named fragments of programs, functions, subroutines, routines), statement labels, events or conditions, and in general, anything a computer programmer can choose to ''name'', but not being restricted to this list. ''Identifiers'' might be another name for ''symbols''.

* [[Idiomatically_determine_all_the_lowercase_and_uppercase_letters|Idiomatically determine all the lowercase and uppercase letters]].

<br><br>

 

=={{header|AWK}}==

 

function is_valid_identifier(id, rc) {

length(bad2), length(good2), good2)

exit(0)

<p>output:</p>

<pre>

2nd..nth char: 193 bad, 63 ok: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz

</pre>

 

=={{header|F_Sharp|F#}}==

Well, if the purpose of this task is to determine what can be used as an identifier then in F# anything so long as you enclose it in double backticks so:

let ``+`` = 5

printfn "%d" ``+``

{{out}}

<pre>

{{output?}}

 

{{out}}

<pre>

From this code we can see that any characters may be used in an identifier unless it parses as a string or a number.

 

 

This program uses the Go parser to check whether an identifier is indeed valid.

It checks separately which Unicode code points may appear at the beginning of an identifier, or in the remaining name.

or of length 2 starting with the underscore.

 

 

import (

_, _ = fmt.Println("Valid follow:", validFollow.String())

_, _ = fmt.Println("Only follow:", validOnlyFollow.String())

{{out}}

<pre>

Only follow: U+0030-U+0039, U+0660-U+0669, U+06F0-U+06F9, U+07C0-U+07C9, ..., U+1D7CE-U+1D7FF, U+1E950-U+1E959

</pre>

 

=={{header|J}}==

J is defined in terms of ascii, but that would not prevent it from being ported to other environments. But we can still use J's parser to determine if a specific character combination is a single, legal word:

 

 

Here, [http://www.jsoftware.com/help/dictionary/dadot.htm a.] is the set of chararacters we are testing. We prefix each of these with an arbitrary letter, and suffix each with an arbitrary character and then try counting how many parsed tokens are formed by the result. If the token count is 1, then that character was a legal word-forming character.

=={{header|Java}}==

{{works with|Java|8}}

import java.util.stream.IntStream;

 

System.out.println("...");

}

 

<pre>Java Identifier start: $ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz¢£¤¥ªµºÀÁÂÃÄÅÆÇÈÉÊ...

 

To generate a string of such characters idiomatically:

 

jq 1.5 also allows ":" as a joining character in the form "module::name".

Therefore, assuming the availability in jq of the test/1 builtin, the test

in jq for whether a character can appear literally in a jq identifier or key is:

 

===Symbols===

The following function screens for characters by "\p" class:

For example, to test whether a character is a Unicode letter, symbol or numeric character:

 

An efficient way to count the number of Unicode characters within a character class is

to use the technique illustrated by the following function:

reduce (range(m;n) | [.] | implode | select( test( "\\p{" + class + "}" ))) as $i

 

For example the number of Unicode "symbol" characters can be obtained by evaluating:

The result is 3958.

 

 

For example, x2 is a valid identifier, but 2x is not-- it is interpreted as 2 times the identifier x. In Julia, the Symbol() function turns a string into a symbolic token. So, for example:

for i in 1:0x200000 - 1

Symbol("x" * Char(i))

end

 

When run, this loop runs without error up to 0x200000 but not at Unicode symbol numbered 0x200000.

 

A Kotlin label name is a valid identifier followed by an @ symbol and an annotation name is an identifier preceded by an @ symbol.

 

typealias CharPredicate = (Char) -> Boolean

printChars("Kotlin Identifier ignorable: ", 0, 0x10FFFF, 25,

Character::isIdentifierIgnorable, true)

 

{{out}}

Kotlin Identifier ignorable: [0][1][2][3][4][5][6][7][8][14][15][16][17][18][19][20][21][22][23][24][25][26][27][127][128]...

</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

out = Reap[Do[

If[Quiet[Length[Symbol[c]] == 0],

{c, chars}

]][[2, 1]];

{{out}}

In Wolfram Language almost all characters (there are 1114112 characters defined) can be used in variable/function names. I can't show all valid characters as there are over a million that are allowed. I do not show the list of characters 'out' but rather their length for practical purposes:

As regards identifiers, there exists a general rule which describes how they can be formed. For this rule, the following program prints the allowed starting characters and the allowed characters:

 

 

echo "Allowed starting characters for identifiers:"

echo ""

echo "Allowed characters in identifiers:"

 

{{out}}

But Nim is a lot more flexible and allows using Unicode symbols in identifiers provided these are letters and digits. Thus, the following program is valid:

 

 

Using escape character <code>`</code>, it is possible to override the rules and to include any character in an identifier and even to use a keyword as identifier. Here is an example of the possibilities:

 

echo `const`

 

var `1` = 2

echo `1`

 

=={{header|Ol}}==

Although this program does not use any feature that is not in Classic Rexx,

it is included here to show what characters are valid for symbols in ooRexx.

/* copied from REXX version 2 */

Parse Version v

symbol_characters=symbol_characters || c /* add to list. */

end

{{out}}

<pre>REXX-ooRexx_4.2.0(MT)_32-bit 6.04 22 Feb 2014

=={{header|PARI/GP}}==

The only symbols that can be used in variable names (including function names as a special case) are a-z, A-Z, 0-9, and the underscore. Additionally, the first character must be a letter. (That is, they must match this regex: <code>[a-zA-Z][a-zA-Z0-9_]*</code>.)

{{out}}

<pre>%1 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "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", "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", "_"]</pre>

 

=={{header|Perl}}==

# the loop below returns: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz

for $i (0..0x7f) {

$c = chr($_);

print $c if $c =~ /\p{Word}/;

 

=={{header|Phix}}==

Translation of AWK, extended with separation of ansi and utf8 handling

{{out}}

<pre>

=={{header|Quackery}}==

 

$ QsTtUuVvWwXxYyZz()[]{}<>~=+-*/^\|_.,:;?!'"`%@&#$Q

join ] constant is tokenchars ( --> $ )

[ i^ validtoken if [ i^ emit ] ] ] is alltokens ( --> )

 

'''Output:'''

That's too much to be printing out here... call <code>(main)</code> yourself, at home.

 

;; Symbols that don't need to be specially quoted:

(printf "~s~%" '(a a-z 3rd ...---... .hidden-files-look-like-this))

(when (zero? (modulo i 80)) (newline))

(display (list->string (list c)))))

 

{{out}}

(formerly Perl 6)

Any Unicode character or combination of characters can be used for symbols in Raku. Here's some counting rods and some cuneiform:

 

sub term:<𝍧> { unival('𝍧') }

 

{{out}}

<pre>8 trilobites</pre>

And here is a Zalgo-text symbol:

 

 

 

{{out}}

<pre>HE COMES</pre>

 

Actually, the above is a slight prevarication. The syntactic category notation does not allow you to use whitespace in the definition of a new symbol. But that leaves many more characters allowed than not allowed. Hence, it is much easier to enumerate the characters that <em>cannot</em> be used in symbols:

if uniprop($_,'Z')

{{out}}

<pre> 20 SPACE

=={{header|REXX}}==

===version 1===

@= /*set symbol characters " " */

do j=0 for 2**8 /*traipse through all the chars. */

 

say ' symbol characters: ' @ /*display all symbol characters.*/

Programming note: &nbsp; REXX allows any symbol to begin a (statement) label, but variables can't begin with a period ('''.''') or a numeric digit.

<br><br>All examples below were executed on a (ASCII) PC using Windows/XP and Windows/7 with code page 437 in a DOS window.

</pre>

I've added version 2 which should work correctly for all Rexx interpreters and compilers

/* version 1 adapted for general acceptance */

Parse Version v

end

say 'symbol characters:' symbol_characters /*display all */

{{out}} for some interpreters

Note that $#@ are not valid symbol characters for ooRexx.

REXX-Regina_3.8.2(MT) 5.00 22 Jun 2014

symbol characters: !#$.0123456789?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz

</pre>

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/ZyPkGW8/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/4XdxscWGTtyw9MDQXCtRdg Scastie (remote JVM)].

 

private def print(msg: String, limit: Int, p: Int => Boolean, fmt: String) =

print("Unicode Identifier part : ", 25, cp => Character.isUnicodeIdentifierPart(cp), "[%d]")

 

 

=={{header|Tcl}}==

Tcl permits ''any'' character to be used in a variable or command name (subject to the restriction that <code>::</code> is a namespace separator and, for variables only, a <code>(…)</code> sequence is an array reference). The set of characters that can be used after <code>$</code> is more restricted, excluding many non-letter-like symbols, but still large. It is ''recommended practice'' to only use ASCII characters for variable names as this makes scripts more resistant to the majority of encoding problems when transporting them between systems, but the language does not itself impose such a restriction.

set ch [format "%c" $c]

set v "_${ch}_"

puts "All Unicode characters legal in names"

}

{{out}}

Only the first 256 characters are displayed:

 

Identifiers which begin with underscores can only be used as instance field names (one underscore) or static field names (two or more underscores).

for (i in 65..90) System.write(String.fromByte(i))

 

{{out}}

=={{header|XPL0}}==

Paraphrasing code from the compiler's parser:

[Text(0, "First character set: ");

for C:= 0 to 255 do

];

CrLf(0);

 

{{out}}

=={{header|zkl}}==

zkl only supports ASCII, although other character sets might be finessed.

try{ Compiler.Compiler.compileText("var "+n.text) }

catch{ False }

{{out}}

<pre>