Case-sensitivity of identifiers: Difference between revisions

=={{header|11l}}==

11l identifiers are case sensitive.

V Dog = ‘Samba’

V DOG = ‘Bernie’

=={{header|Action!}}==

CHAR ARRAY dog="Bernie"

PrintF("There is just one dog named %S.",dog)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Case-sensitivity_of_identifiers.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

case insensitive

procedure Dogs is

Dog : String := "Bernie";

begin

Ada.Text_IO.Put_Line ("There is just one dog named " & DOG);

Output:

=={{header|Agena}}==

Translation of Algol W. Agena is case sensitive, as this example demonstrates. Tested with Agena 2.9.5 Win32

local dog := "Benjamin";

scope

epocs

epocs

{{out}}

<pre>

=={{header|Aime}}==

dog = "Benjamin";

DOG = "Bernie";

=={{header|ALGOL 68}}==

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

A joke code entry... :-) ¢ but the code does actually work!

# -*- coding: utf-8 -*- #

printf(($"The three dogs are named "g", "g" and "g"."l$, dog, Dog, DOGgy));

0

<pre>

The three dogs are named Benjamin, Samba and Bernie.

<br>

However, depending on the "stropping" convention used and the implementation, Algol 68 can be case-sensitive. Rutgers ALGOL 68 uses quote stropping and allows both upper and lower case in identifiers and bold words. The standard bold words must be in lower-case.

'string' dog = "Benjamin";

'begin'

'end'

'end'

{{out}}

=={{header|ALGOL W}}==

Algol W identifiers are not case-sensitive but variable names in inner blocks can be the same as those in outer blocks...

string(8) dog;

dog := "Benjamin";

end

end

{{out}}

<pre>

=={{header|APL}}==

Dog←'Samba'

dog←'Bernie'

'The three dogs are named ',DOG,', ',Dog,', and ',dog

=={{header|Arturo}}==

Dog: "Samba"

DOG: "Bernie"

dogs: @[dog Dog DOG]

{{out}}

=={{header|AutoHotkey}}==

Dog := "Samba"

DOG := "Bernie"

=={{header|AWK}}==

dog = "Benjamin"

Dog = "Samba"

DOG = "Bernie"

printf "The three dogs are named %s, %s and %s.\n", dog, Dog, DOG

The three dogs are named Benjamin, Samba and Bernie.

{{works with|QBasic}}

QBASIC is case-insensitive

DOG$ = "Samba"

DOG$ = "Bernie"

=={{header|BASIC256}}==

BASIC256 is case-insensitive

Dog = "Samba"

DOG = "Bernie"

print "There is just one dog, named "; dog

=={{header|Batch File}}==

@echo off

echo There is just one dog named %dog%.

pause>nul

{{out}}

<pre>

=={{header|BBC BASIC}}==

Dog$ = "Samba"

DOG$ = "Bernie"

Output:

<pre>The three dogs are Benjamin, Samba and Bernie.</pre>

The only variables are 'a' through 'z'. They can only hold numbers, not strings. Some implementations allow longer names like 'dog', but only with lowercase letters. A name like 'Dog' or 'DOG' is a syntax error.

ibase = 16

d = BE27A312

"There is just one dog named "; d

There is just one dog named BE27A312

=={{header|Bracmat}}==

& Samba:?Dog

& Bernie:?DOG

& out$("There are three dogs:" !dog !Dog and !DOG)

Output:

<pre>There are three dogs: Benjamin Samba and Bernie</pre>

The three dogs are drawn as spheres in this simple example:

opendb dogs.g y # Create a database to hold our dogs

units ft # The dogs are measured in feet

in Dog.s sph 4 0 0 3 # Samba is a Labrador

in DOG.s sph 13 0 0 5 # Bernie is massive. He is a New Foundland

=={{header|C}}==

C is case sensitive; if it would be case insensitive, an error about redefinition of a variable would be raised.

static const char *dog = "Benjamin";

printf("The three dogs are named %s, %s and %s.\n", dog, Dog, DOG);

return 0;

=={{header|C sharp|C#}}==

C# is case sensitive

using System;

Console.WriteLine(string.Format("The three dogs are named {0}, {1}, and {2}.", dog, Dog, DOG));

}

=={{header|C++}}==

C++ is case-sensitive.

#include <string>

using namespace std;

cout << "The three dogs are named " << dog << ", " << Dog << ", and " << DOG << endl;

{{out}}

<pre>The three dogs are named Benjamin, Samba, and Bernie</pre>

=={{header|COBOL}}==

*>* Commented-out lines in the working storage

*>* are considered as invalid redefinitions

END-DISPLAY

STOP RUN.

=={{header|CoffeeScript}}==

dog="Benjamin"

Dog = "Samba"

DOG = "Bernie"

console.log "The three dogs are names #{dog}, #{Dog}, and #{DOG}."

output

> coffee foo.coffee

The three dogs are names Benjamin, Samba, and Bernie.

=={{header|Common Lisp}}==

(format nil "There is just one dog named ~a." dog))

; in: LAMBDA NIL

; compilation unit finished

; caught 2 STYLE-WARNING conditions

These are the style warnings from [[SBCL]]. Other implementations of Common Lisp might give different warnings.

=={{header|Crystal}}==

Dog = "Samba"

DOG = "Bernie"

Note that in Crystal, variables with all-caps identifiers (like <code>DOG</code>) are always constants.

=={{header|D}}==

void main() {

writefln("There are three dogs named ",

dog, ", ", Dog, ", and ", DOG, "'");

Output:

<pre>There are three dogs named Benjamin, Samba, and Bernie'</pre>

A register name has only one character, so this example uses 'd' and 'D'.

[Samba]sD

[The two dogs are named ]P ldP [ and ]P lDP [.

{{Out}}

Delphi is case insensitive.

{$APPTYPE CONSOLE}

DOG := 'Bernie';

Writeln('There is just one dog named ' + dog);

Output:

=={{header|DWScript}}==

var dog : String;

DOG := 'Bernie';

Output:

=={{header|Déjà Vu}}==

local :Dog "Samba"

local :DOG "Bernie"

{{out}}

<pre>There are three dogs named Benjamin, Samba and Bernie.</pre>

=={{header|EchoLisp}}==

(define dog "Benjamin")

(define Dog "Samba")

(printf "The three dogs are named %a, %a and %a. " dog Dog DOG)

The three dogs are named Benjamin, Samba and Bernie.

=={{header|Elena}}==

In ELENA identifiers are case sensitive.

ELENA 4.x:

public program()

var DOG := "Bernie";

console.printLineFormatted("The three dogs are named {0}, {1} and {2}", dog, Dog, DOG)

{{out}}

<pre>

=={{header|Elixir}}==

While Elixir's identifiers are case-sensitive, they generally must start with a lowercase letter. Capitalized identifiers are reserved for modules.

doG = "Samba"

dOG = "Bernie"

{{out}}

=={{header|Erlang}}==

Erlang variables are case sensitive but must start with an uppercase letter.

-module( case_sensitivity_of_identifiers ).

DOG = "Bernie",

io:fwrite( "The three dogs are named ~s, ~s and ~s~n", [dog, Dog, DOG] ).

{{out}}

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

sequence dog = "Benjamin"

sequence Dog = "Samba"

sequence DOG = "Bernie"

=={{header|F Sharp|F#}}==

F# is case-sensitive.

let Dog = "Samba"

let DOG = "Bernie"

=={{header|Factor}}==

Factor identifiers are case-sensitive.

IN: scratchpad

[let

"Bernie" :> DOG

{ dog Dog DOG } "There are three dogs named %s, %s, and %s." vprintf

{{out}}

<pre>

=={{header|Forth}}==

: Dog ." Samba" ;

: dog ." Bernie" ;

: HOWMANYDOGS ." There is just one dog named " DOG ;

{{out}}

<pre>There is just one dog named Bernie</pre>

{{works with|Fortran|90 and later}}

Fortran is case insensitive, and so the three "dog" variants name the same variable - which therefore is multiply declared and will likely evoke a compiler complaint.

implicit none

end if

Output:

<pre> There is just one dog named Bernie</pre>

=={{header|FreeBASIC}}==

' FreeBASIC is case-insensitive

DOG = "Bernie"

Print "There is just one dog, named "; dog

{{out}}

=={{header|Frink}}==

Frink is case-sensitive.

Dog = "Samba"

DOG = "Bernie"

=={{header|Gambas}}==

Gambas in case insensitive

Dim dog As String

Print "There is just one dog, named "; dog

Output:

<pre>

=={{header|GAP}}==

ThreeDogs := function()

local dog, Dog, DOG;

ThreeDogs();

=={{header|Go}}==

Go is case sensitive. Further, visibility depends on case. See the Go entry under the [[Scope_modifiers#Go|Scope modifiers]] task.

import "fmt"

// the variables really represent different places in memory.

return map[*string]int{&dog: 1, &Dog: 1, &DOG: 1}

import (

d[&DOG] = 1

fmt.Println("There are", len(d), "dogs.")

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

Output:

Identifiers are case sensitive in Haskell, but must start with a lower case letter.

main = printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg

where dog = "Benjamin"

dOG = "Samba"

=={{header|Icon}} and {{header|Unicon}}==

The program below demonstrates the three dog task. All variants of Icon/Unicon have case sensitive variable names. But if one wasn't this would find it.

dog := "Benjamin"

write("The three dogs are named ", dog, ", ", Dog, " and ", DOG, ".")

=={{header|J}}==

dog=: 'Benjamin'

Dog=: 'Samba'

DOG=: 'Bernie'

'The three dogs are named ',dog,', ',Dog,', and ',DOG

=={{header|Java}}==

String Dog = "Samba"; //in general, identifiers that start with capital letters are class names

String DOG = "Bernie"; //in general, identifiers in all caps are constants

//the conventions listed in comments here are not enforced by the language

=={{header|JavaScript}}==

Javascript is case sensitive.

var Dog = "Samba";

var DOG = "Bernie";

=={{header|jq}}==

'''Function parameters''':

"The three dogs are named \(dog), \(Dog), and \(DOG)." ;

{{Out}}

'''Variable names''':

{{out}}

As above.

{{works with|Julia|0.6}}

Variable names are case sensitive.

if dog === Dog

else

println("The three dogs are: ", dog, ", ", Dog, " and ", DOG)

{{out}}

=={{header|K}}==

dog: "Benjamin"

Dog: "Samba"

"There are three dogs named ",dog,", ",Dog," and ",DOG

"There are three dogs named Benjamin, Samba and Bernie"

=={{header|Kotlin}}==

Kotlin is case-sensitive though (as in Java) the convention is for local variable names to begin with a lower case letter. The second and third identifiers would therefore be unlikely to be used in practice.

val dog = "Benjamin"

val Dog = "Samba"

val DOG = "Bernie"

println("The three dogs are named $dog, $Dog and $DOG")

{{out}}

=={{header|Lasso}}==

Lasso is not case sensitive for names

local(dog = 'Benjamin')

local(Dog = 'Samba')

stdoutnl('There is just one dog named ' + #dog)

Output:

<pre>There is just one dog named Bernie</pre>

Same with string comparisons. (Lasso maps can only contain unique keys)

local(dogs = map(

'dog' = 'Benjamin',

'DOG' = 'Bernie'

))

Output:

<pre>1</pre>

To get case sensitivity we need to use bytes

local(dogs = map(

bytes('dog') = 'Benjamin',

stdoutnl(#dogs -> size)

Output:

<pre>3

=={{header|Liberty BASIC}}==

NB the IDE warns you that there are similar variables named dog$, Dog$ & DOG$

dog$ = "Benjamin"

Dog$ = "Samba"

end

The three dogs are Benjamin, Samba and Bernie.

=={{header|Lua}}==

Dog = "Samba"

DOG = "Bernie"

<pre>There are three dogs named Benjamin, Samba and Bernie.</pre>

Types in Enumeration are case sensitive, identifiers are not case sensitive.

MoDuLe CheckIT {

\\ keys as case sensitive if they are strings

}

Checkit

=={{header|Maple}}==

> if nops( { dog, Dog, DOG } ) = 3 then

> printf( "There are three dogs named %s, %s and %s.\n", dog, Dog, DOG )

> printf( "There is one dog named %s.\n", dog )

> end if:

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

"The three dogs are named "<> dog <>", "<> Dog <>" and "<> DOG

=={{header|MATLAB}} / {{header|Octave}}==

Dog = 'Samba';

DOG = 'Bernie';

Output

=={{header|Maxima}}==

a: 1$

A: 2$

is(a = A);

=={{header|min}}==

{{works with|min|0.19.3}}

min's symbols are case sensitive.

"Samba" :Dog

"Bernie" :DOG

{{out}}

<pre>

=={{header|MiniScript}}==

Dog = "Samba"

DOG = "Bernie"

=={{header|Modula-2}}==

IMPORT InOut;

InOut.WriteString ("Three happy dogs.");

InOut.WriteLn

=={{header|Nanoquery}}==

Dog = "Samba"

DOG = "Bernie"

{{out}}

<pre>The three dogs are named Benjamin, Samba, and Bernie.</pre>

=={{header|Nemerle}}==

def Dog = "Samba";

def DOG = "Bernie";

=={{header|NESL}}==

NESL is completely case-insensitive.

Dog = "Samba";

DOG = "Bernie";

{{out}}

<pre>it = "There is just one dog, named Bernie" : [char]</pre>

=={{header|NetRexx}}==

NetRexx is not case sensitive:

options replace format comments java crossref symbols nobinary

return

'''Output:'''

<pre>

With these rules, we don’t get one dog or three dogs: we get two dogs!

(dog, Dog, DOG) = ("Benjamin", "Samba", "Bernie")

echo "There are two dogs: ", dog, " and ", DOG

else:

{{out}}

=={{header|Oberon-2}}==

{{Works with| oo2c Version 2}}

MODULE CaseSensitivity;

IMPORT

Out.Ln

END CaseSensitivity.

{{Out}}

<pre>

Objeck is case sensitive

function : Main(args : String[]) ~ Nil {

dog := "Benjamin";

"The three dogs are named {$dog}, {$Dog}, and {$DOG}."->PrintLine();

}

=={{header|OCaml}}==

Identifiers in OCaml are lettercase sensitive, but the first letter has to be lowercase.

let dog = "Benjamin" in

let dOG = "Samba" in

let dOg = "Bernie" in

=={{header|Oforth}}==

Oforth is case-sensitive.

| dog Dog DOG |

"Bernie" ->DOG

=={{header|Ol}}==

(define dog "Benjamin")

(define Dog "Samba")

(print "The three dogs are named " dog ", " Dog " and " DOG ".\n")

{{Out}}

<pre>

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

Dog="Samba";

DOG="Bernie";

=={{header|Pascal}}==

=={{header|Perl}}==

$dog='Benjamin';

$Dog='Samba';

$DOG='Bernie';

=={{header|Phix}}==

Phix is case sensitive

<span style="color: #004080;">sequence</span> <span style="color: #000000;">dog</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Benjamin"<span style="color: #0000FF;">,</span>

<span style="color: #000000;">Dog</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Samba"<span style="color: #0000FF;">,</span>

<span style="color: #000000;">DOG</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Bernie"</span>

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(</span> <span style="color: #000000;">1<span style="color: #0000FF;">,</span> <span style="color: #008000;">"The three dogs are named %s, %s and %s\n"<span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{<span style="color: #000000;">dog<span style="color: #0000FF;">,</span> <span style="color: #000000;">Dog<span style="color: #0000FF;">,</span> <span style="color: #000000;">DOG<span style="color: #0000FF;">}</span> <span style="color: #0000FF;">)

{{out}}

=={{header|PicoLisp}}==

Output:

<pre>The three dogs are named Benjamin, Samba and Bernie</pre>

=={{header|PL/I}}==

/*********************************************************************

* Program to show that PL/I is case-insensitive

DOG = "Bernie";

Put Edit(dog,Dog,DOG)(Skip,3(a,x(1)));

'''Output'''

<pre>Bernie Bernie Berni</pre>

=={{header|Plain English}}==

Plain English is NOT case sensitive.

Start up.

Put "Benjamin" into a DOG string.

Write "There is just one dog named " then the DOG on the console.

Wait for the escape key.

{{out}}

<pre>

=={{header|PowerShell}}==

PowerShell is not case sensitive.

$dog = "Benjamin"

$Dog = "Samba"

"There is just one dog named {0}." -f $dOg

{{Out}}

<pre>

=={{header|Prolog}}==

In Prolog, the initial of a variable must be a uppercase letter. So the task can't be completed but we can write this code :

DoG = 'Benjamin',

Dog = 'Samba',

DOG = 'Bernie',

format('The three dogs are named ~w, ~w and ~w.~n', [DoG, Dog, DOG]).

The output is :

<pre>?- three_dogs.

=={{header|PureBasic}}==

Dog$="Samba"

DOG$="Bernie"

=={{header|Python}}==

Python names are case sensitive:

>>> print ('The three dogs are named ',dog,', ',Dog,', and ',DOG)

The three dogs are named Benjamin , Samba , and Bernie

=={{header|Quackery}}==

[ $ 'Samba' ] is Dog ( --> $ )

dog echo$ say ', '

Dog echo$ say ', and '

{{out}}

<pre>

=={{header|R}}==

Dog <- 'Samba'

DOG <- 'Bernie'

cat('.\n')

# In one line it would be:

Output:

=={{header|Racket}}==

The default setting for the Racket reader is to be case sensitive:

#lang racket

(define dog "Benjamin")

(displayln (~a "There is one dog named " DOG "."))

(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG ".")))

Output:

<pre>

If you need case insensitive identifiers, then use #ci to turn on case insensitivity:

#lang racket

#ci(module dogs racket

(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG "."))))

(require 'dogs)

Output:

<pre>

=={{header|Raku}}==

(formerly Perl 6)

my $Dog = 'Samba';

my $DOG = 'Bernie';

The only place that Raku pays any attention to the case of identifiers is that, for certain error messages, it will guess that an identifier starting lowercase is probably a function name, while one starting uppercase is probably a type or constant name. But this case distinction is merely a convention in Raku, not mandatory:

sub Dog() { 'Samba' }

my &DOG = { 'Bernie' }

=={{header|Retro}}==

Retro is case sensitive.

: Dog ( -$ ) "Samba" ;

: DOG ( -$ ) "Bernie" ;

=={{header|REXX}}==

===simple variables===

The REXX language is case insensitive &nbsp; (with respect to simple variables).

/* ┌──◄── all 3 left─hand side REXX variables are identical (as far as assignments). */

else say 'There is just one dog named:' dog"."

'''output'''

<pre>

===compound variables===

However, the REXX language is case sensitive &nbsp; (with respect to compound variables, or indices).

/* ┌──◄── all 3 indices (for an array variable) are unique (as far as array index). */

_= 'doG'; say "dogname.doG=" dogname._ /* " " " " mixed doG*/

'''output'''

<pre>

=={{header|Ring}}==

dog = "Benjamin"

doG = "Smokey"

DOG = "Bernie"

see "The 4 dogs are : " + dog + ", " + doG + ", " + Dog + " and " + DOG + "."

=={{header|Ruby}}==

Ruby gives a special meaning to the first letter of a name. A lowercase letter starts a local variable. An uppercase letter starts a constant. So <tt>dog</tt> is a local variable, but <tt>Dog</tt> and <tt>DOG</tt> are constants. To adapt this task to Ruby, I added <tt>dOg</tt> and <tt>doG</tt> so that I have more than one local variable.

dog = "Benjamin"

dOg = "Dogley"

puts "The local variables are %s." % local_variables.join(", ")

puts "The constants are %s." % constants.join(", ")

Output: <pre>There are 5 dogs named Benjamin, Dogley, Fido, Samba, Bernie.

=={{header|Run BASIC}}==

dog$ = "Benjamin"

doG$ = "Smokey"

DOG$ = "Bernie"

print "The 4 dogs are "; dog$; ", "; doG$; ", "; Dog$; " and "; DOG$; "."

=={{header|Rust}}==

Rust style dictates that identifiers should be written in snake case, e.g. <tt>big_dog</tt>, <tt>small_dog</tt>; whereas types (structs and enums) should be written in camel case, e.g. <tt>BigDog</tt>, <tt>SmallDog</tt>. Failing to comply with this standard does not cause a compiler error, but it will trigger a compiler warning, and the culture is very strongly towards compliance with this standard.

let dog = "Benjamin";

let Dog = "Samba";

let DOG = "Bernie";

println!("The three dogs are named {}, {} and {}.", dog, Dog, DOG);

This triggers two warnings at compilation:

<anon>:3 let Dog = "Samba";

^~~

<anon>:4:9: 4:12 warning: variable `DOG` should have a snake case name such as `dog`, #[warn(non_snake_case)] on by default

<anon>:4 let DOG = "Bernie";

The resulting program will compile and run just fine, producing the output:

=={{header|Sather}}==

all uppercase.

main is

dog ::= "Benjamin";

dog, Dog, DOG);

end;

Outputs:

=={{header|Scala}}==

val Dog = "Samba"

val DOG = "Bernie"

Output:

<pre>There are three dogs named Benjamin, Samba, and Bernie.</pre>

=={{header|Scheme}}==

Output may differ depending on implementation.

(define Dog "Samba")

(define DOG "Bernie")

(display DOG)

(display ".")

=={{header|Seed7}}==

const string: dog is "Benjamin";

begin

writeln("The three dogs are named " <& dog <& ", " <& Dog <& " and " <& DOG <& ".");

=={{header|SenseTalk}}==

As a People Oriented Programming language, SenseTalk's variable names are case-insensitive.

set dog to "Benjamin"

set Dog to "Samba"

put !"There is just one dog named [[dog]]."

{{out}}

<pre>There is just one dog named Bernie.</pre>

=={{header|SETL}}==

Dog := 'Samba';

DOG := 'Bernie';

{{out}}

<pre>There is just one dog named Bernie</pre>

=={{header|Sidef}}==

var Dog = 'Samba';

var DOG = 'Bernie';