Case-sensitivity of identifiers: Difference between revisions

* [[Unicode variable names]]

<br><br>

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

11l identifiers are case sensitive.

V Dog = ‘Samba’

V DOG = ‘Bernie’

print(‘The three dogs are named ’dog‘, ’Dog‘ and ’DOG‘.’)</syntaxhighlight>

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

CHAR ARRAY dog="Bernie"

 

There is just one dog named Bernie.

</pre>

=={{header|Ada}}==

case insensitive

procedure Dogs is

Dog : String := "Bernie";

Output:

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

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

The three dogs are named: Benjamin, Samba and Bernie

</pre>

=={{header|Aime}}==

 

dog = "Benjamin";

 

o_form("The three dogs are named ~, ~ and ~.\n", dog, Dog, DOG);</syntaxhighlight>

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

{{works with|ALGOL 68|Revision 1.}}

{{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 -*- #

 

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

The three dogs are named: Benjamin, Samba and Bernie

</pre>

=={{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";

There is just one dog named: Bernie

</pre>

=={{header|APL}}==

Dog←'Samba'

dog←'Bernie'

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

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

=={{header|Arturo}}==

 

Dog: "Samba"

DOG: "Bernie"

 

<pre>The 3 dog(s) are named Benjamin, Samba, Bernie</pre>

=={{header|AutoHotkey}}==

Dog := "Samba"

DOG := "Bernie"

MsgBox There is just one dog named %dOG%</syntaxhighlight>

=={{header|AWK}}==

dog = "Benjamin"

Dog = "Samba"

 

The three dogs are named Benjamin, Samba and Bernie.

=={{header|BASIC}}==

{{works with|QBasic}}

QBASIC is case-insensitive

DOG$ = "Samba"

DOG$ = "Bernie"

PRINT "There is just one dog, named "; DOG$</syntaxhighlight>

=={{header|BASIC256}}==

BASIC256 is case-insensitive

Dog = "Samba"

DOG = "Bernie"

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

end</syntaxhighlight>

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

@echo off

 

There is just one dog named Bernie.

</pre>

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

Dog$ = "Samba"

DOG$ = "Bernie"

Output:

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

=={{header|bc}}==

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

 

 

There is just one dog named BE27A312

=={{header|Bracmat}}==

& Samba:?Dog

& Bernie:?DOG

Output:

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

=={{header|Brlcad}}==

 

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 13 0 0 5 # Bernie is massive. He is a New Foundland

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

=={{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";

return 0;

}</syntaxhighlight>

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

C# is case sensitive

using System;

 

}

}</syntaxhighlight>

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

C++ is case-sensitive.

#include <string>

using namespace std;

{{out}}

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

=={{header|Clojure}}==

<pre>user=> (let [dog "Benjamin" Dog "Samba" DOG "Bernie"] (format "The three dogs are named %s, %s and %s." dog Dog DOG))

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

=={{header|COBOL}}==

*>* Commented-out lines in the working storage

*>* are considered as invalid redefinitions

STOP RUN.

END PROGRAM case-sensitivity.</syntaxhighlight>

=={{header|CoffeeScript}}==

dog="Benjamin"

Dog = "Samba"

 

output

> coffee foo.coffee

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

</syntaxhighlight>

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

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

; in: LAMBDA NIL

 

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

=={{header|Crystal}}==

Dog = "Samba"

DOG = "Bernie"

{{out}}

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

=={{header|D}}==

 

void main() {

Output:

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

=={{header|dc}}==

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

<pre>The two dogs are named Benjamin and Samba.</pre>

=={{header|Delphi}}==

Delphi is case insensitive.

 

 

{$APPTYPE CONSOLE}

Output:

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

=={{header|DWScript}}==

var dog : String;

 

Output:

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

=={{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")

The three dogs are named Benjamin, Samba and Bernie.

</syntaxhighlight>

=={{header|Elena}}==

In ELENA identifiers are case sensitive.

ELENA 4.x:

 

public program()

The three dogs are named Benjamin, Samba and Bernie

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

The three dogs are named Benjamin, Samba and Bernie.

</pre>

=={{header|Erlang}}==

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

-module( case_sensitivity_of_identifiers ).

 

The three dogs are named dog, Samba and Bernie

</pre>

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

sequence dog = "Benjamin"

sequence Dog = "Samba"

sequence DOG = "Bernie"

printf( 1, "The three dogs are named %s, %s and %s\n", {dog, Dog, DOG} )</syntaxhighlight>

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

F# is case-sensitive.

let Dog = "Samba"

let DOG = "Bernie"

printfn "There are three dogs named %s, %s and %s" dog Dog DOG</syntaxhighlight>

=={{header|Factor}}==

Factor identifiers are case-sensitive.

IN: scratchpad

[let

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

</pre>

=={{header|Forth}}==

: Dog ." Samba" ;

: dog ." Bernie" ;

{{out}}

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

=={{header|Fortran}}==

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

 

Output:

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

=={{header|FreeBASIC}}==

 

' FreeBASIC is case-insensitive

There is just one dog, named Bernie

</pre>

=={{header|Frink}}==

Frink is case-sensitive.

Dog = "Samba"

DOG = "Bernie"

println["There are three dogs named $dog, $Dog and $DOG"]</syntaxhighlight>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=fed58074944b894f5d4cfb8e16c6819a Click this link to run this code]'''

 

Gambas in case insensitive

Dim dog As String

 

There is just one dog, named Bernie

</pre>

=={{header|GAP}}==

ThreeDogs := function()

local dog, Dog, DOG;

ThreeDogs();

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

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

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

}</syntaxhighlight>

 

import (

There are 5 dogs.

</pre>

=={{header|Groovy}}==

Solution:

println (dog == DOG ? "There is one dog named ${dog}" : "There are three dogs named ${dog}, ${Dog} and ${DOG}.")</syntaxhighlight>

 

Output:

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

=={{header|Haskell}}==

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

dOG = "Samba"

dOg = "Bernie"</syntaxhighlight>

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

 

end</syntaxhighlight>

=={{header|J}}==

dog=: 'Benjamin'

Dog=: 'Samba'

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

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

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

System.out.println("There are three dogs named " + dog + ", " + Dog + ", and " + DOG + "'");</syntaxhighlight>

=={{header|JavaScript}}==

Javascript is case sensitive.

var Dog = "Samba";

var DOG = "Bernie";

document.write("The three dogs are named " + dog + ", " + Dog + ", and " + DOG + ".");</syntaxhighlight>

=={{header|jq}}==

jq identifiers are case-sensitive.

 

'''Function parameters''':

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

 

 

'''Variable names''':

| "The three dogs are named \($dog), \($Dog), and \($DOG)."</syntaxhighlight>

{{out}}

As above.

=={{header|Julia}}==

{{works with|Julia|0.6}}

Variable names are case sensitive.

 

if dog === Dog

 

Conventionally, variable names should be all lower case. Type and Macro names should be capitalized.

=={{header|K}}==

dog: "Benjamin"

Dog: "Samba"

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

</syntaxhighlight>

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

The three dogs are named Benjamin, Samba and Bernie

</pre>

=={{header|Lasso}}==

Lasso is not case sensitive for names

local(dog = 'Benjamin')

local(Dog = 'Samba')

 

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

local(dogs = map(

'dog' = 'Benjamin',

 

To get case sensitivity we need to use bytes

local(dogs = map(

bytes('dog') = 'Benjamin',

<pre>3

Samba </pre>

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

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

dog$ = "Benjamin"

Dog$ = "Samba"

</syntaxhighlight>

The three dogs are Benjamin, Samba and Bernie.

=={{header|Lua}}==

Dog = "Samba"

DOG = "Bernie"

print( "There are three dogs named "..dog..", "..Dog.." and "..DOG.."." )</syntaxhighlight>

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

=={{header|M2000 Interpreter}}==

Labels are case sensitive, but identifiers are not case sensitive.

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

 

MoDuLe CheckIT {

\\ keys as case sensitive if they are strings

Checkit

</syntaxhighlight>

=={{header|Maple}}==

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

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

> end if:

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

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

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

 

-> "The three dogs are named Benjamin, Samba and Bernie"</syntaxhighlight>

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

 

Dog = 'Samba';

DOG = 'Bernie';

 

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

=={{header|Maxima}}==

a: 1$

A: 2$

is(a = A);

false</syntaxhighlight>

=={{header|min}}==

{{works with|min|0.19.3}}

min's symbols are case sensitive.

"Samba" :Dog

"Bernie" :DOG

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

</pre>

=={{header|MiniScript}}==

Dog = "Samba"

DOG = "Bernie"

 

print "There are three dogs named " + dog + ", " + Dog + " and " + DOG</syntaxhighlight>

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

 

IMPORT InOut;

InOut.WriteLn

END dog.</syntaxhighlight>

=={{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";

WriteLine($"The three dogs are named $dog, $Dog, and $DOG");</syntaxhighlight>

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

 

There is just one dog named Bernie.

</pre>

=={{header|Nim}}==

Nim has peculiar rules regarding case and style sensitivity:

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

 

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

{{out}}

<pre>There are two dogs: Benjamin and Bernie</pre>

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

{{Works with| oo2c Version 2}}

MODULE CaseSensitivity;

IMPORT

The three dogs are named Benjamin, Samba and Bernie

</pre>

=={{header|Objeck}}==

Objeck is case sensitive

 

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

dog := "Benjamin";

}

}</syntaxhighlight>

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

Printf.printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg</syntaxhighlight>

=={{header|Oforth}}==

 

Oforth is case-sensitive.

 

| dog Dog DOG |

 

 

System.Out "The three dogs are named " << dog << ", " << Dog << " and " << DOG << "." << cr ;</syntaxhighlight>

=={{header|Ol}}==

(define dog "Benjamin")

(define Dog "Samba")

The three dogs are named Benjamin, Samba and Bernie.

</pre>

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

Dog="Samba";

DOG="Bernie";

printf("The three dogs are named %s, %s, and %s.", dog, Dog, DOG)</syntaxhighlight>

=={{header|Pascal}}==

See [[#Delphi|Delphi]]

=={{header|Perl}}==

$dog='Benjamin';

$Dog='Samba';

$DOG='Bernie';

print "The three dogs are named $dog, $Dog, and $DOG \n"</syntaxhighlight>

=={{header|Phix}}==

{{libheader|Phix/basics}}

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>

The three dogs are named Benjamin, Samba and Bernie

</pre>

=={{header|PicoLisp}}==

(prinl "The three dogs are named " dog ", " Dog " and " DOG) )</syntaxhighlight>

Output:

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

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

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

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

'''Output'''

<pre>Bernie Bernie Berni</pre>

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

Plain English is NOT case sensitive.

Start up.

Put "Benjamin" into a DOG string.

There is just one dog named Bernie

</pre>

=={{header|PowerShell}}==

PowerShell is not case sensitive.

$dog = "Benjamin"

$Dog = "Samba"

There is just one dog named Bernie.

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

 

</pre>

=={{header|PureBasic}}==

Dog$="Samba"

DOG$="Bernie"

Debug "There is just one dog named "+dog$</syntaxhighlight>

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

>>> </syntaxhighlight>

=={{header|Quackery}}==

 

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

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

</pre>

=={{header|R}}==

Dog <- 'Samba'

DOG <- 'Bernie'

The three dogs are named Benjamin, Samba and Bernie.

</pre>

=={{header|Racket}}==

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

#lang racket

(define dog "Benjamin")

 

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

#lang racket

#ci(module dogs racket

There is one dog named Bernie.

</pre>

=={{header|Raku}}==

(formerly Perl 6)

my $Dog = 'Samba';

my $DOG = 'Bernie';

say "The three dogs are named $dog, $Dog, and $DOG."</syntaxhighlight>

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

say "The three dogs are named {dog}, {Dog}, and {DOG}."</syntaxhighlight>

=={{header|Retro}}==

Retro is case sensitive.

 

: Dog ( -$ ) "Samba" ;

: DOG ( -$ ) "Bernie" ;

 

DOG Dog dog "The three dogs are named %s, %s, and %s.\n" puts</syntaxhighlight>

=={{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). */

===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). */

dogname.doG= Rex

</pre>

=={{header|Ring}}==

dog = "Benjamin"

doG = "Smokey"

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

</syntaxhighlight>

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

The local variables are dog, dOg, doG, names.

The constants are Dog, DOG.</pre>

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

dog$ = "Benjamin"

doG$ = "Smokey"

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

</syntaxhighlight>

=={{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";

This triggers two warnings at compilation:

 

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

^~~

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

 

=={{header|Sather}}==

Though by convention Sather uses all uppercase letters for class names, a variable can be

all uppercase.

 

main is

dog ::= "Benjamin";

 

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

=={{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 ".")

(newline)))</syntaxhighlight>

=={{header|Seed7}}==

 

const string: dog is "Benjamin";

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

end func;</syntaxhighlight>

=={{header|SenseTalk}}==

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

set dog to "Benjamin"

set Dog to "Samba"

{{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';

{{out}}

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

=={{header|Simula}}==

Simula identifiers are case-insensitive, and the compiler will indignantly reject a program that tries to declare multiple variables with names differing only in case. (Same with ''key words'': Case of a character in Simula ''code'' generally only matters in [http://simula67.at.ifi.uio.no/Standard-86/chap_1.htm| a simple string or a character constant].)

text dog;

dog :- blanks( 8 );

{{out}}

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

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

Smalltalk's symbols are case sensitive.

 

dog := 'Benjamin'.

Dog := 'Samba'.

 

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

=={{header|SNOBOL4}}==

Dog = 'Samba'

dog = 'Bernie'

{{out}}

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

=={{header|Standard ML}}==

Standard ML is case sensitive.

val dog = "Benjamin"

val Dog = "Samba"

{{out}}

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

=={{header|Stata}}==

Stata is case-sensitive.

 

. local Dog Samba

. local DOG Bernie

. display "The three dogs are named $_dog, $_Dog, and $_DOG."

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

=={{header|Swift}}==

let Dog = "Samba"

let DOG = "Bernie"

println("The three dogs are named \(dog), \(Dog), and \(DOG).")</syntaxhighlight>

=={{header|Tcl}}==

Tcl variable names are case sensitive:

set Dog "Samba"

set DOG "Bernie"

Which prints...

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

=={{header|True BASIC}}==

{{works with|QBasic}}

True Basic is case-insensitive

LET Dog$ = "Samba"

LET DOG$ = "Bernie"

PRINT "There is just one dog, named "; dog$

END</syntaxhighlight>

=={{header|UNIX Shell}}==

Dog="Samba"

DOG="Bernie"

 

The three dogs are named Benjamin, Samba and Bernie.

=={{header|Ursa}}==

Ursa names are case sensitive:

> set dog "Benjamin"

> set Dog "Samba"

The three dogs are named Benjamin, Samba, and Bernie

></syntaxhighlight>

=={{header|VBA}}==

VBA is case sensitive case insensitive. The variable names 'dog', 'Dog' and 'DOG' can not co-exist.

'VBA does not allow variables that only differ in case

'The VBA IDE vbe will rename variable 'dog' to 'DOG'

End Sub</syntaxhighlight>{{out}}

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

=={{header|Wren}}==

Identifiers in Wren are case sensitive.

var Dog = "Samba"

var DOG = "Bernie"

The three dogs are named Benjamin, Samba and Bernie.

</pre>

=={{header|XBS}}==

In XBS variable names are case-sensitive.

set DOG="Samba";

set Dog="Bernie";

The three dogs are named Benjamin, Samba and Bernie.

</pre>

=={{header|XLISP}}==

XLISP is entirely case-insensitive. The user can decide whether to have the system print symbols, etc., in capitals or in lower case, by assigning to the variable <tt>*PRINT-CASE*</tt>.

(SETQ Dog 'SAMBA)

(SETQ dog 'BERNIE)

There is, in any event, only one dog.

<pre>(THERE IS JUST ONE DOG NAMED BERNIE)</pre>

=={{header|XPL0}}==

XPL0 is normally case-insensitive, so there is really just one dog named

switch (/c) is to detect inconsistent capitalizing of names such as

Ascii and ASCII or CpuReg and CPUReg.

=={{header|Yabasic}}==

Yabasic names are case sensitive:

dog$ = "Benjamin"

Dog$ = "Samba"

print "The three dogs are named ", dog$, ", ", Dog$, " and ", DOG$

end</syntaxhighlight>

=={{header|zkl}}==

{{out}}

<pre>

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

</pre>

=={{header|ZX Spectrum Basic}}==

20 PRINT "There is just one dog named ";d$</syntaxhighlight>

{{omit from|360 Assembly}}

{{omit from|6502 Assembly|Depends on assembler. Some have a -nocase command line argument that ignores sensitivity of labels.}}

{{omit from|8051 Assembly}}

{{omit from|8080 Assembly}}

{{omit from|8086 Assembly}}

{{omit from|AArch64 Assembly}}

{{omit from|ARM Assembly}}