Adding the ?. null verification

[Meta via Digitalmars-d]

On Wednesday, 18 June 2014 at 19:37:42 UTC, H. S. Teoh via 
Digitalmars-d wrote:
> Here's a first stab at a library solution:
>
> 	/**
> 	 * Simple-minded implementation of a Maybe monad.
> 	 *
> 	 * Params: t = data to wrap.
> 	 * Returns: A wrapper around the given type, with "safe" 
> member dereference
> 	 * semantics, that is, if t is null, then any further member 
> dereferences will
> 	 * just return a wrapper around the .init value of the wrapped 
> type, instead of
> 	 * deferencing the null and crashing.
> 	 */
> 	auto maybe(T)(T t) {
> 		static struct Maybe {
> 			T t;
> 	
> 			// Make the wrapper as transparent as possible.
> 			alias t this;
> 	
> 			// This is the magic that makes it all work.
> 			auto opDispatch(string field)()
> 				if (is(typeof(__traits(getMember, t, field))))
> 			{
> 				alias Memb = typeof(__traits(getMember, t, field));
> 	
> 				// If T is comparable with null, then we do a null
> 				// check. Otherwise, we just dereference the member
> 				// since it's guaranteed to be safe of null
> 				// dereferences.
> 				//
> 				// N.B.: we always return a wrapped type in case the
> 				// return type contains further nullable fields.
> 				static if (is(typeof(t is null))) {
> 					return maybe((t is null) ? Memb.init
> 								: __traits(getMember, t, field));
> 				} else {
> 					return maybe(__traits(getMember, t, field));
> 				}
> 			}
> 		}
> 		return Maybe(t);
> 	}
> 	
> 	/**
> 	 * A sample tree structure to test the above code.
> 	 */
> 	class Node {
> 		int val;
> 		Node left, right;
> 	
> 		this(int _val, Node _left=null, Node _right=null) {
> 			val = _val;
> 			left = _left;
> 			right = _right;
> 		}
> 	}
> 	
> 	void main() {
> 		import std.stdio;
> 	
> 		auto tree = new Node(1,
> 			new Node(2),
> 			new Node(3,
> 				null,
> 				new Node(4)
> 			)
> 		);
> 	
> 		writeln(maybe(tree).right.right.val);
> 		writeln(maybe(tree).left.right.left.right);
> 		writeln(maybe(tree).left.right.left.right.val);
> 	}
>
> Program output:
>
> 	4
> 	Maybe(null)
> 	0
>
> It's not perfect, but as you can see, attempting to dereference 
> null
> just returns the result type's .init value. You can also modify 
> the code
> where it returns Memb.init, to also log a message to a debug 
> log that
> indicates a possible logic problem with the code (failure to 
> check for
> null, etc.).
>
> This also allows you to do a complete null check in a single 
> statement:
>
> 	if (maybe(tree).left.right.right.left.right !is null) {
> 		// do something with that value
> 	}
>
> If nothing else, this at least saves you the trouble of having 
> to check
> every intermediate reference in the chain. :)
>
> The only wart I can see currently is the "Maybe(null)" 
> appearing in the
> writeln output, instead of just "null", but that can be worked 
> around by
> implementing a toString method in the Maybe struct that 
> forwards to the
> wrapped type's toString method (or something along those lines).
>
> Anyway, this is just a first shot at it. You can probably build
> something more sophisticated out of it. :)
>
>
> T

That's nifty. opDispatch can do some cool stuff.