Null object

Null object
You are encouraged to solve this task according to the task description, using any language you may know.

Null (or nil) is the computer science concept of an undefined or unbound object. Some languages have an explicit way to access the null object, and some don't. Some languages distinguish the null object from undefined values, and some don't.

Show how to access null in your language by checking to see if an object is equivalent to the null object.

This task is not about whether a variable is defined. The task is about "null"-like values in various languages, which may or may not be related to the defined-ness of variables in your language.

ActionScript

<lang actionscript>if (object == null)

   trace("object is null");</lang>

ActionScript also has an undefined value: see Undefined values#ActionScript.

Ada

<lang ada>with Ada.Text_Io;

if Object = null then

  Ada.Text_Io.Put_line("object is null");

end if;</lang>

ALGOL 68

In ALGOL 68 the NIL yields a name that does not refer to any value. NIL can never be naturally coerced and can only appear where the context is strong.

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

<lang algol68>REF STRING no result = NIL; STRING result := "";

IF no result :=: NIL THEN print(("no result :=: NIL", new line)) FI; IF result :/=: NIL THEN print(("result :/=: NIL", new line)) FI;

IF no result IS NIL THEN print(("no result IS NIL", new line)) FI; IF result ISNT NIL THEN print(("result ISNT NIL", new line)) FI;

COMMENT using the UNESCO/IFIP/WG2.1 ALGOL 68 character set

 result := °;
 IF REF STRING(result) :≠: ° THEN print(("result ≠ °", new line)) FI;

END COMMENT

1. Note the following gotcha: #

REF STRING var := NIL; IF var ISNT NIL THEN print(("The address of var ISNT NIL",new line)) FI; IF var IS REF STRING(NIL) THEN print(("The address of var IS REF STRING(NIL)",new line)) FI</lang> Output:

no result :=: NIL
result :/=: NIL
no result IS NIL
result ISNT NIL
The address of var ISNT NIL
The address of var IS REF STRING(NIL)

NIL basically is an untyped ref (pointer) that does not refer anywhere.

ALGOL 68 also has empty. This is a "constant" of size 0 and type void. c.f. Roots of a function for two different examples of usage.

• empty as an undefined argument to a routine.
• empty as a routine return if no result is found.

empty is typically used to refer to am empty leaf in a tree structure.

Basically:

• ALGOL 68's empty is python's None,
• ALGOL 68's void is python's NoneType, and
• ALGOL 68's nil is python's hash(None)

AmigaE

<lang amigae>DEF x : PTR TO object -> ... IF object <> NIL

 -> ...

ENDIF</lang>

AppleScript

Many applications will return missing value, but null is also available. <lang AppleScript>if x is missing value then

 display dialog "x is missing value"

end if

if x is null then

 display dialog "x is null"

end if</lang>

AutoHotkey

<lang AutoHotkey>If (object == null)

 MsgBox, object is null</lang>

C

C has the null pointer, written as "0", whose internal representation is often, though not always, the same as integer zero. It is (supposedly) garanteed to be pointing to nothing, so receiving one of those likely means you are not looking at an object--but, there are occasions where changing content of a null pointer actually does something (say, on DOS); and a function that's supposed to return a pointer on success doesn't always return a 0 otherwise (e.g. mmap returns -1 for failure).

There is a very common macro, NULL, which evaluates to (void*) 0 or an equivalent value. NULL is compatible with all pointer types, including both data pointers and function pointers.

The standard library defines NULL in locale.h, stddef.h, stdio.h, stdlib.h, string.h, time.h and wchar.h. POSIX systems also define NULL in dirent.h and unistd.h. Many C files include at least one of these headers, so NULL is almost always available.

<lang c>#include <stdio.h>

int main() { char *object = 0;

if (object == NULL) { puts("object is null"); } return 0; }</lang>

C++

In C++ non-pointer types do not support null. (C++ provides value semantics rather than reference semantics). When using pointers C++ permits checking for null by comparing the pointer to a literal of 0, or (as in C) by way of a macro (NULL) which simply expands to 0. <lang cpp>#include <iostream>

1. include <cstdlib>

if (object == 0) {

  std::cout << "object is null";

}</lang>

boost::optional is available for cases where the programmer wishes to pass by value, but still support a null value.

<lang cpp>

1. include <boost/optional.hpp>
2. include <iostream>

boost::optional<int> maybeInt()

int main() {

 boost::optional<int> maybe = maybeInt();

 if(!maybe)
   std::cout << "object is null\n";

} </lang>

C#

As with Java, any reference type may be null, and testing for nullity uses ordinary boolean operators. <lang csharp>if (foo == null)

   Console.WriteLine("foo is null");</lang>

C# 2.0 introduced nullable types for situations in which even primitive value types may have undefined or unknown values (for example, when reading from a database). Prior to the introduction of nullable types, these situations would require writing wrapper classes or casting to a reference type (e.g., object), incurring the penalties of boxing and reduced type safety. A variable with nullable type can be declared simply by adding the '?' operator after the type.

Works with: C# version 2.0+

<lang csharp>int? x = 12; x = null;</lang>

Also new in C# 2.0 was the null coalescing operator, '??', which is simply syntactic sugar allowing a default value to replace an operand if the operand is null:

Works with: C# version 2.0+

<lang csharp>Console.WriteLine(name ?? "Name not specified");

//Without the null coalescing operator, this would instead be written as: //if(name == null){ // Console.WriteLine("Name not specified"); //}else{ // Console.WriteLine(name); //}</lang>

Clojure

Clojure's nil is equivalent to Java's null.

<lang lisp>(let [x nil]

(println "Object is" (if (nil? x) "nil" "not nil")))</lang>

Test wether symbol foo is defined:

<lang lisp>(find (ns-interns *ns*) 'foo)</lang>

Undefining foo:

<lang lisp>(ns-unmap *ns* 'foo)</lang>

Common Lisp

Basics

Common Lisp has an object denoted by the symbol nil. When the symbol nil is evaluated as an expression, it evaluates to itself.

nil uniquely represents boolean false, and so code like <lang lisp>(if (condition) (do-this))</lang> is actually testing whether (condition) returns the value nil. The object nil is also used to denote the empty list which also terminates other lists. The value is also used as a default when some function returns fewer values than expected. (list (values)) produces (nil) (list containing one element, which is the empty list), because (values) produces no value, but the function call (list ...) needs to reduce the expression to a single argument value, and so nil is supplied.

Beginnings of Null Object

The idea of making functions accept nil without failing did not appear in early Lisps. For instance (car nil) was erroneous: it was incorrect to try to access the first element of a non-list.

The defaulting behavior (car nil) which Common Lisp programmers take for granted was introduced in InterLisp, and then copied into MacLisp. (InterLisp had other liberties that do not survive into Common Lisp: it was possible to call a function with insufficient arguments, and the missing ones defaulted to nil. Likewise, excess arguments were ignored. CL has a disciplined syntax and semantics for default and variable arguments.)

This (car nil) -> nil behavior shows nil in an kind of new role: the role of a null object which takes methods that apply to other objects and provides some default non-failing behavior. It is the beginnings of the [null object design pattern].

Object-Oriented Null Object

In Common Lisp, in fact, there is a class called null, of which the object nil is understood to be the only instance. Furthermore, the null class is at the bottom of the type spindle: it is a subclass of every class. This is in contrast with the type T which is a superclass of every class.

Since null is at the bottom of the class hierarchy, it is possible to write methods specialized to parameters of class null which will only be applicable if the argument is the object nil. No other object is a subtype of null.

Some traditional Lisp functions could be expressed using the object system like this. Suppose that the car function did not have a safe defaulting behavior for nil. We could use the methods of the object system to define a car* which does have the safe behavior:

<lang lisp>(defmethod car* ((arg cons))

 (car arg))

(defmethod car* ((arg null))

 nil)</lang>

Now if we invoke car* on something which is neither a cons, nor nil, we get an error about no applicable method being found.

We can handle that ourselves by writing a method specialized to the master supertype t:

<lang lisp>(defmethod car* ((arg t))  ;; can just be written (defmethod car* (arg) ...)

 (error "CAR*: ~s is neither a cons nor nil" arg))</lang>

The classes t and null are widely exploited in Lisp OO programming.

D

Library: tango

In D is is used for comparing identity, like two objects or an object against null. <lang d>import tango.io.Stdout;

if(object is null) {

  Stdout.formatln("object is null");

}</lang>

Delphi

<lang Delphi> // the following are equivalent

 if lObject = nil then
 ...
 
 if not Assigned(lObject) then 
 ...</lang>

DWScript

See Delphi

E

<lang e>object == null</lang>

Factor

<lang factor>: is-f? ( obj -- ? ) f = ;</lang>

Fantom

Test for equality with 'null', which is the null value.

<lang fantom> fansh> x := null fansh> x == null true fansh> x = 1 1 fansh> x == null false </lang>

Note, nullable objects have a type ending in a question mark, for example:

Int? y := null is valid, but

Int y := null is not.

Forth

Standard ANS Forth does not distinguish a particular invalid memory value like NULL. Instead, ALLOCATE returns an out-of-band success code to indicate a failed allocation. Dictionary words have the option of throwing an exception on a dictionary space overrun. Forth lacks a NULL symbol because it has such a wide variety of target platforms. On some embedded targets, the memory space may be as small as 64 direct-mapped addresses, where eliminating a valid zero address would have a high price.

In practice, all notable hosted implementations follow the C practice of being able to treat a zero address (i.e. FALSE) as a null address for the purpose of list termination.

Go

Nil is a predefined identifier, defined for six types in Go. In each case, it represents the zero value for the type, that is, the memory representation of all zero bytes. This is the value of a newly created object. In the cases of these six types, an object must be subsequently initialized in some way before it has much use. Examples of initialization are given in the Go solution of task Undefined values. <lang go> package main

import "fmt"

var (

   s []int       // slice type
   p *int        // pointer type
   f func()      // function type
   i interface{} // interface type
   m map[int]int // map type
   c chan int    // channel type

)

func main() {

   fmt.Println(s == nil)
   fmt.Println(p == nil)
   fmt.Println(f == nil)
   fmt.Println(i == nil)
   fmt.Println(m == nil)
   fmt.Println(c == nil)

} </lang> Output is "true" in each case.

Haskell

Haskell does not have a universal null value. There is a 'value of every type', the undefined value (sometimes written ⊥, 'bottom'), but it is essentially a sort of exception — any attempt to use it is an error.

<lang haskell>undefined -- undefined value provided by the standard library error "oops" -- another undefined value head [] -- undefined, you can't take the head of an empty list</lang>

When one would use "null" as a marker for "there is no normal value here" (e.g. a field which is either an integer or null), one uses the Maybe type instead. The definition of Maybe is:

<lang haskell> data Maybe a = Nothing | Just a</lang>

That is, a Maybe Integer is either Nothing or Just <some integer>.

There are many ways to work with Maybe, but here's a basic case expression:

<lang haskell>case thing of

Nothing -> "It's Nothing. Or null, whatever."
Just v  -> "It's not Nothing; it is " ++ show v ++ "."</lang>

Icon and Unicon

Icon/Unicon have a null value/datatype. It isn't possible to undefine a variable.

<lang Icon>procedure main() nulltest("a",a) # unassigned variables are null by default nulltest("b",b := &null) # explicit assignment is possible nulltest("c",c := "anything") nulltest("c",c := &null) # varibables can't be undefined end

procedure nulltest(name,var) return write(name, if /var then " is" else " is not"," null.") end</lang>

Io

<lang io>if(object == nil, "object is nil" println)</lang>

J

J doesn't have NULL. To indicate "missing data", "normal" data is usually pressed into service (e.g. 0 or _1 in a numeric context, ' ' in a literal context, a: in a boxed context, etc). Frequently, missing data is represented by the empty vector '', or other arrays without any elements.

However, undefined names in J can be identified:

<lang J>isUndefined=: _1 = nc@boxxopen</lang>

Example use:

<lang J> isUndefined 'foo' 1

  foo=:9
  isUndefined 'foo'

0</lang>

Note, however, that this "name is not defined" state is not a first class value in J -- you can not create a list of "undefineds".

Note: the concept of an empty array can be natural in J (and APL) for representing data which is not there -- it is the structural equivalent of the number zero. That said, its implications can sometimes be non-obvious for people coming from a languages which requires that arrays have content. As a result, you will sometimes encounter empty array jokes...

Marie Pennysworth, having spent a productive day shopping, stopped by Robert Cuttingham's butcher shop.

"How much for your t-bones," she asked.

"Eleven dollars per pound," he responded.

"How about for your sirloin?" she continued.

"Sirloin is thirteen dollars per pound today," he answered.

"But Harkin's Grocery down the street is selling sirloin for nine dollars per pound!" she exclaimed.

"So, why don't you buy it from them?" he asked.

"Well, they're out," she sighed.

He smiled, "When I am out, I only charge seven dollars a pound."

That said, note that the usual way to indicate missing or invalid data, in J, is to have a parallel array which is a bit mask (which selects the desired or valid values). Or, as a logical equivalent: a list of indices which select the desired and/or valid values. Alternatively, you can have an array without the invalid values and a bit mask which demonstrates how the data would be populated on a larger array -- in other words instead of 3,4,null,5 you could have (3 4 5) and (1 1 0 1). And you can transform between some of these representations:

<lang j> 1 1 0 1#3 4 _ 5 3 4 5

  I.1 1 0 1

0 1 3

  0 1 3 { 3 4 _ 5

3 4 5

  1 1 0 1 #inv 3 4 5

3 4 0 5

  1 1 0 1 #!._ inv 3 4 5

3 4 _ 5</lang>

Java

In Java, "null" is a value of every reference type. <lang java>// here "object" is a reference if (object == null) {

  System.out.println("object is null");

}</lang>

JavaScript

<lang javascript>if (object !== undefined)

 alert("object is defined")</lang>

K

K has well developed notions of data null :

The special numeric atoms 0I and 0N refer to integer infinity and “not-a-number” (or “null” in database parlance) concepts, and similarly 0i and 0n for floating-point.

eg : ( 1 2 3 0N 6 7 )

and and missing value nil :

Empty expressions in both list expressions and function expressions actually represent a special atomic value called nil. ... A list may contain one or more empty items (i.e. the nil value _n), which are typically indicated by omission:

<lang k>

 (1;;2) ~ (1 ; _n ; 2)    /  ~  is identical to or match .

1

 _n ~' ( 1 ; ; 2 )        /  match each

0 1 0

additional properties : _n@i and _n?i are i; _n`v is _n </lang>

Logo

<lang logo>to test :thing if empty? :thing [print [list or word is empty]] end

print empty? []  ; true print empty? "|| ; true</lang>

Lua

<lang lua> isnil = (object == nil) print(isnil) </lang>

Mathematica

Mathematica can assign a Null value to a symbol, two examples: <lang Mathematica>x=Null;</lang> <lang Mathematica>x =. x = (1 + 2;) FullForm[x]</lang> Both set x to be Null. To specifically test is something is Null one can use the SameQ function (with infix operator: ===): <lang Mathematica>SameQ[x,Null]</lang> Or equivalent: <lang Mathematica>x===Null</lang> will give back True if and only if x is assigned to be Null. If x is empty (nothing assigned) this will return False. To test if an object has something assigned (number, list, graphics, null, infinity, symbol, equation, pattern, whatever) one uses ValueQ: <lang Mathematica>x =.; ValueQ[x] x = 3; ValueQ[x]</lang> gives: <lang Mathematica>False True</lang>

MAXScript

<lang maxscript>if obj == undefined then print "Obj is undefined"</lang>

Modula-3

In Modula-3, NIL is a value, and NULL is a type. The NULL type contains only one value, NIL. NULL is a subtype of all reference types, which allows all reference types to have the value NIL.

This can lead to errors, if for example you write: <lang modula3>VAR foo := NIL</lang> This (most likely incorrectly) gives foo the type NULL, which can only have the value NIL, so trying to assign it anything else will not work. To overcome this problem, you must specify the reference type when declaring foo: <lang modula3>VAR foo: REF INTEGER := NIL;</lang> <lang modula3>IF foo = NIL THEN

 IO.Put("Object is nil.\n");

END;</lang>

MUMPS

A variable can be declared implicitly by using it as on the left side in a SET, or by making a new version for the current scope with a NEW statement. A variable can have descendants without having a value set.

The $DATA (or $D) function will return a number:

$DATA returns:	Variable is defined
Variable has children		No	Yes
	No	0	1
	Yes	10	11

Or, by examples (in immediate mode):

<lang MUMPS> CACHE>WRITE $DATA(VARI) 0 CACHE>SET VARI="HELLO" WRITE $DATA(VARI) 1 CACHE>NEW VARI WRITE $DATA(VARI) ;Change to a new scope 0 CACHE 1S1>SET VARI(1,2)="DOWN" WRITE $DATA(VARI) 10 CACHE 1S1>WRITE $DATA(VARI(1)) 10 CACHE 1S1>WRITE $D(VARI(1,2)) 1 CACHE 1S1>SET VARI(1)="UP" WRITE $DATA(VARI(1)) 11 <CACHE 1S1>QUIT ;Leave the scope

<CACHE>W $DATA(VARI)," ",VARI 1 HELLO </lang>

Objective-C

The value nil is used to indicate that an object pointer (variable of type id) doesn't point to a valid object. <lang objc>// here "object" is an object pointer if (object == nil) {

  NSLog("object is nil");

}</lang> An interesting thing is that in Objective-C, it is possible to send a message to nil, and the program will not crash or raise an exception (nothing will be executed and nil will be returned in place of the usual return value). <lang objc>[nil fooBar];</lang>

Note that nil is distinct from NULL, which is only used for regular C pointers.

For class pointers (values of type Class), they have a separate null pointer value called Nil.

Confusingly, there is also NSNull, a singleton class with one value, [NSNull null], used as a dummy object to represent the lack of a useful object. This is needed in collections like arrays and dictionaries, etc., because they do not allow nil elements, so if you want to represent some "empty" slots in the array you would use this.

Objeck

In Objeck, "Nil" is a value of every reference type. <lang Objeck>

1. here "object" is a reference

if(object = Nil) {

  "object is null"->PrintLine();

}; </lang>

OCaml

Maybe the closest type of OCaml would be the type option, which is defined like this in the standard library: <lang ocaml>type 'a option = None | Some of 'a</lang> <lang ocaml>match v with | None -> "unbound value" | Some _ -> "bounded value"</lang>

Oz

There is no explicit null in Oz.

Unbound variables

If an unbound variable is accessed, the current thread will be suspended: <lang oz>declare

 X

in

 {Show X+2}  %% blocks</lang>

If you later assign a value to X in another thread, the original thread will resume and print the result of the addition. This is the basic building block of Oz' declarative concurrency.

Undefined values

Access to undefined values (like using an out-of-range array index or a non-existing record feature) will usually provoke an exception in Oz.

It is also possible to assign a unique "failed" value to a variable. Such a failed value encapsulates an exception. This can be useful in concurrent programming to propagate exceptions across thread boundaries. <lang oz>declare

 X = {Value.failed dontTouchMe}

in

 {Wait X}  %% throws dontTouchMe</lang>

Sometimes algebraic data types like Haskell's Maybe are simulated using records. <lang oz>declare

 X = just("Data")

in

 case X of nothing then skip
 [] just(Result) then {Show Result}
 end</lang>

PARI/GP

GP does not have good facilities for this, but this test suffices for most purposes: <lang parigp>foo!='foo</lang>

Pascal

See Delphi

Perl

In Perl, undef is a special scalar value, kind of like null in other languages. A scalar variable that has been declared but has not been assigned a value will be initialized to undef. (Array and hash variables are initialized to empty arrays or hashes.)

If strict mode is not on, you may start using a variable without declaring it; it will "spring" into existence, with value undef. In strict mode, you must declare a variable before using it. Indexing an array or hash with an index or key that does not exist, will return undef (however, this is not an indication that the index or key does not exist; rather, it could be that it does exist, and the value is undef itself). If warnings is on, most of the time, if you use the undef value in a calculation, it will produce a warning. undef is considered false in boolean contexts.

It is possible to use undef like most other scalar values: you can assign it to a variable (either by doing $var = undef; or undef($var);), return it from a function, assign it to an array element, assign it to a hash element, etc. When you do list assignment (i.e. assign a list to a list of variables on the left side), you can use undef to "skip" over some elements of the list that you don't want to keep.

You can check to see if a value is undef by using the defined operator: <lang perl>print defined($x) ? 'Defined' : 'Undefined', ".\n";</lang> From the above discussion, it should be clear that if defined returns false, it does not mean that the variable has not been set; rather, it could be that it was explicitly set to undef.

Starting in Perl 5.10, there is also a defined-or operator in Perl. For example: <lang perl>say $number // "unknown";</lang> prints $number if it is defined (even if it is false) or the string "unknown" otherwise.

Perl 6

Translation of: Haskell

(as it were...)

In Perl 6 you can name the concept of Nil, but it not considered an object, but rather the absence of an object, more of a "bottom" type. The closest analog in real objects is an empty list, but an empty list is considered defined, while Nil.defined always returns false. Nil is what you get if you try to read off the end of a list, and () is just very easy to read off the end of... :-)

If you try to put Nil into a container, you don't end up with a container that has Nil in it. Instead the container reverts to an uninitialized state that is consistent with the declared type. Hence, Perl 6 has the notion of typed undefined values, that are real objects in the sense of "being there", but are generic in the sense of representing type information without being instantiated as a real object. We call these type objects since they can stand in for real objects when one reasons about the types of objects. So type objects fit into the type hierarchy just as normal objects do. In physics terms, think of them as "type charge carriers" that are there for bookkeeping between the "real" particles.

All type objects derive from Mu, the most-undefined type object, and the object most like "null" in many languages. All other object types derive from Mu, so it is like Object in other languages as well, except Mu also encompasses various objects that are not discrete, such as junctions. So Perl 6 distinguishes Mu from Any, which is the type that functions the most like a discrete, mundane object.

Mostly the user doesn't have to think about it. All object containers behave like "Maybe" types in Haskell terms; they may either hold a valid value or a "nothing" of an appropriate type. Most containers default to an object of type Any so you don't accidentally send quantum superpositions (junctions) around in your program.

<lang perl6>my $var; say $var.WHAT; # Any() $var = 42; say $var.WHAT; # Int() say $var.defined; # True $var = Nil; say $var.WHAT; # Any() say $var.defined # False</lang>

You can declare a variable of type Mu if you wish to propagate superpositional types:

<lang perl6>my Mu $junction; say $junction.WHAT; # Mu() $junction = 1 | 2 | 3; say $junction.WHAT; # Junction()</lang>

Or you can declare a more restricted type than Any

<lang perl6>my Str $str; say $str.WHAT; # Str() $str = "I am a string."; say $str.WHAT; # Str() $str = 42; # (fails)</lang>

But in the Perl 6 view of reality, it's completely bogus to ask for a way "to see if an object is equivalent to the null object." The whole point of such a non-object object is that it doesn't exist, and can't participate in computations. If you think you mean the null object in Perl 6, you really mean some kind of generic object that is uninstantiated, and hence undefined. One of those is your "null object", except there are many of them, so you can't just check for equivalence. Use the defined predicate (or match on a subclass of your type that forces recognition of abstraction or definedness).

Perl 6 also has Failure objects that, in addition to being undefined carriers of type, are also carriers of the reason for the value's undefinedness. We tend view them as lazily thrown exceptions, at least until you try to use them as defined values, in which case they're thrown for real.

PHP

There is a special value NULL. You can test for it using is_null() or !isset() <lang php>$x = NULL; if (is_null($x))

 echo "\$x is null\n";</lang>

PicoLisp

New internal symbols are initialized with the value NIL. NIL is also the value for "false", so there is never really an "undefined value". 'not' is the predicate to check for NIL, but many other (typically flow control) functions can be used. <lang PicoLisp>(if (not MyNewVariable)

  (handle value-is-NIL) )</lang>

or <lang PicoLisp>(unless MyNewVariable

  (handle value-is-NIL) )</lang>

Pike

In Pike all variables are initialized to $0$, regardless of their type. thus $0$ functions as a Null value for all types except integer.

$0$ is also used to indicate the absence of a key or object member.

to tell the difference between a value $0$ and absence of a key, zero_type() is used: <lang Pike>> mapping bar; > bar; Result: 0 > bar = ([ "foo":0 ]); > bar->foo; Result 0; > zero_type(bar->foo); Result: 0 > bar->baz; Result: 0 > zero_type(bar->baz); Result: 1</lang>

PL/I

<lang PL/I> declare x fixed decimal (10); ... if ^valid(x) then signal error;

declare y picture 'A9XAAA9'; ... if ^valid(y) then signal error; </lang> Comment:- In the picture specification, the content of variable y must consist of letters where the letter 'A' is given, digits or space where the digit '9' appears, and the letter X signfies that any character is acceptable.

PowerShell

In PowerShell the automatic variable $null represents a null value. Comparisons are not left/right symmetrical which means placing $null on the left side greatly assists when comparing to an array. <lang powershell>if ($null -eq $object) {

   ...

}</lang>

PureBasic

All variables that has not yet been given any other value will be initiated to #Null <lang PureBasic>If variable = #Null

 Debug "Variable has no value"

EndIf</lang>

Python

<lang python>x = None if x is None:

 print "x is None"

else:

 print "x is not None"</lang>

Output:

x is None

R

R has the special value NULL to represent a null object. You can test for it using the function is.null. Note that R also has a special value NA to represent missing or unknown values. <lang R>is.null(NULL) # TRUE is.null(123) # FALSE is.null(NA) # FALSE 123==NULL # Empty logical value, with a warning foo <- function(){} # function that does nothing foo() # returns NULL</lang>

REBOL

<lang REBOL>x: none

print ["x" either none? x ["is"]["isn't"] "none."]</lang>

Output:

x is none.

REXX

REXX can have variables with a null value.
With the SYMBOL built-in function, it can be determined if a variable is defined (or not).
The LENGTH built-in function can be used to see what the length of the value of a define variable.
A variable with a NULL value has a length of 0 (zero).

The DROP statement can be used to "un-define" a REXX variable. <lang rexx> /*REXX (start of program).*/

if symbol('ABC')=="VAR" then say 'variable ABC is defined, value='abc"<<<"

                       else say "variable ABC isn't defined."

xyz=47 if symbol('XYZ')=="VAR" then say 'variable XYZ is defined, value='xyz"<<<"

                       else say "variable XYZ isn't defined."

drop xyz if symbol('XYZ')=="VAR" then say 'variable XYZ is defined, value='xyz"<<<"

                       else say "variable XYZ isn't defined."

cat= if symbol('CAT')=="VAR" then say 'variable CAT is defined, value='cat"<<<"

                       else say "variable CAT isn't defined."

/*REXX end of program.*/ </lang> Output:

variable ABC isn't defined.
variable XYZ is defined, value=47<<<
variable XYZ isn't defined.
variable CAT is defined, value=<<<

Ruby

<lang ruby>

  puts "object is null" if object.nil?

</lang>

Scheme

<lang scheme>(null? object)</lang> Note: "null?" here tests whether a value is the empty list.

Slate

<lang slate>Nil isNil = True.</lang>

Smalltalk

<lang smalltalk>object isNil ifTrue: [ "true block" ]

            ifFalse: [ "false block" ].

nil isNil ifTrue: [ 'true!' displayNl ]. "output: true!"</lang>

Standard ML

Maybe the closest type of Standard ML would be the type option, which is defined like this in the standard library: <lang sml>datatype 'a option = NONE | SOME of 'a</lang> <lang sml>case v of NONE => "unbound value"

       | SOME _ => "bounded value"</lang>

Tcl

In Tcl, where every value is a string, there is no out-of band value corresponding to NULL. In many cases, using the empty string is sufficient: <lang Tcl>if {$value eq ""} ...</lang> A stricter approximation to NULL can be had with non-existing variables or elements of a dict or array: <lang Tcl>if {![info exist nullvar]} ... if {![info exists arr(nullval)]} ... if {![dict exists $dic nullval]} ...</lang> Note that lists do not support anything like nulls, since they are strictly sequences of values.