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}}==

BEGIN {

}

exit(0)

<p>output:</p>

<pre>

</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>

</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.

 

=={{header|Go}}==

 

import (

"fmt"

"unicode"

)

 

}

 

 

 

}

}

}

}

}

{{out}}

<pre>

</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|ooRexx}}==

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>

ansi characters:

===============

 

===============

</pre>

 

=={{header|Python}}==

See [[Idiomatically_determine_all_the_lowercase_and_uppercase_letters#Python|String class isidentifier]].

 

=={{header|Racket}}==

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}}

(3 i have a space i've got a quote in me i'm not a "dot on my own", but my neighbour is! . λ my characters aren't even mapped in unicode 􎑃)</pre>

The output to <code>(main)</code> is massive, and probably not dissimilar to Tcl's (anyone want to compare?)

 

=={{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:

<pre>All Unicode characters legal in names

Characters legal after $: 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 ª µ º À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ø ù ú û ü ý þ ÿ İ ı IJ ij Ĵ ĵ Ķ ķ ĸ Ĺ Ł ł Ń ń Ņ ņ Ň ň ʼn Ŋ ŋ Ō ō Ŏ ŏ Ő ő Œ œ Ŕ ŕ Ŗ ŗ Ř ř Ś ş š Ţ ţ Ť ť Ŧ ŧ Ũ ũ Ū ū Ŭ ŭ Ů ů Ű ű Ų ų Ŵ ŵ Ŷ ŷ Ÿ Ź ź ƪ Ƶ ƺ ǀ ǁ ǂ ǃ DŽ Dž dž LJ Lj lj NJ Nj nj Ǎ ǎ Ǐ ǐ Ǒ ǒ Ǔ ǔ Ǖ ǖ ǘ Ǚ ǚ Ǜ ǜ ǝ Ǟ ǟ Ǡ ǡ Ǣ ǣ Ǥ ǥ Ǧ ǧ Ǩ ǩ Ǫ ǫ Ǭ ǭ Ǯ ǯ ǰ DZ Dz dz Ǵ ǵ Ƕ Ǹ ǹ Ǻ ǻ Ǽ ǽ Ǿ ǿ ...</pre>

 

=={{header|zkl}}==

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

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

catch{ False }

{{out}}

<pre>