Polish Maybe API a bit, removing useless creativity and fixing some signatures.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 63 matching lines @@
 class Data;
 class Date;
 class External;
 class Function;
 class FunctionTemplate;
 class HeapProfiler;
 class ImplementationUtilities;
 class Int32;
 class Integer;
 class Isolate;
+template <class T>
+class Maybe;
 class Name;
 class Number;
 class NumberObject;
 class Object;
 class ObjectOperationDescriptor;
 class ObjectTemplate;
 class Platform;
 class Primitive;
 class Promise;
 class RawOperationDescriptor;
@@ skipping 872 matching lines @@
   // disallowing certain operations.
   EscapableHandleScope(const EscapableHandleScope&);
   void operator=(const EscapableHandleScope&);
   void* operator new(size_t size);
   void operator delete(void*, size_t);
 
   internal::Object** escape_slot_;
 };
 
 
-/**
- * A simple Maybe type, representing an object which may or may not have a
- * value.
- */
-template <class T>
-class Maybe {
- public:
-  Maybe() : has_value(false) {}
-  explicit Maybe(const T& t) : has_value(true), value(t) {}
-  // TODO(dcarney): remove this constructor, it makes no sense.
-  Maybe(bool has, const T& t) : has_value(has), value(t) {}
-
-  V8_INLINE bool HasValue() const { return has_value; }
-
-  V8_WARN_UNUSED_RESULT V8_INLINE bool ToValue(T* out) const {
-    *out = has_value ? value : T();
-    return has_value;
-  }
-
-  V8_INLINE T ToValueChecked() const {
-    // TODO(dcarney): add DCHECK.
-    return value;
-  }
-
-  V8_INLINE T From(const T& default_value) const {
-    return has_value ? value : default_value;
-  }
-
-  // TODO(dcarney): make private.
-  bool has_value;
-  T value;
-};
-
-
-// Convenience wrapper.
-template <class T>
-inline Maybe<T> maybe(T t) {
-  return Maybe<T>(t);
-}
-
-
 // --- Special objects ---
 
 
 /**
  * The superclass of values and API object templates.
  */
 class V8_EXPORT Data {
  private:
   Data();
 };
@@ skipping 4716 matching lines @@
                           int internal_field_index1,
                           // Must be 1 or kNoInternalFieldIndex.
                           int internal_field_index2,
                           PhantomCallbackData<void>::Callback weak_callback);
   static void* ClearWeak(internal::Object** global_handle);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
                          int* index);
   static Local<Value> GetEternal(Isolate* isolate, int index);
 
+  static void CheckIsJust(bool is_just);
+
   template <class T> friend class Handle;
   template <class T> friend class Local;
+  template <class T>
+  friend class Maybe;
   template <class T> friend class Eternal;
   template <class T> friend class PersistentBase;
   template <class T, class M> friend class Persistent;
   friend class Context;
 };
 
 
 /**
+ * A simple Maybe type, representing an object which may or may not have a
+ * value.
+ */
+template <class T>
+class Maybe {
+ public:
+  // TODO(dcarney): remove this constructor, it makes no sense.
+  Maybe(bool has, const T& t) : has_value(has), value(t) {}
+
+  V8_INLINE bool IsJust() const { return has_value; }

[Nico, 2016/02/26 19:18:26]

I saw this since someone made a similar name change in Blink. I think this is a
way worse name than the "uselessly creative" name we had before. People who know
Haskell will get "isJust" but nobody else will without looking it up. "HasValue"
is immediately understandable. Most people don't know Haskell.

+
+  V8_INLINE T FromJust() const {
+#ifdef V8_ENABLE_CHECKS
+    V8::CheckIsJust(IsJust());
+#endif
+    return value;
+  }
+
+  V8_INLINE T FromMaybe(const T& default_value) const {
+    return has_value ? value : default_value;
+  }
+
+  // TODO(dcarney): make private.
+  bool has_value;
+  T value;
+
+ private:
+  template <class U>
+  friend Maybe<U> Nothing();
+  template <class U>
+  friend Maybe<U> Just(const U& u);
+
+  Maybe() : has_value(false) {}
+  explicit Maybe(const T& t) : has_value(true), value(t) {}
+};
+
+
+template <class T>
+inline Maybe<T> Nothing() {
+  return Maybe<T>();
+}
+
+
+template <class T>
+inline Maybe<T> Just(const T& t) {
+  return Maybe<T>(t);
+}
+
+
+/**
  * An external exception handler.
  */
 class V8_EXPORT TryCatch {
  public:
   /**
    * Creates a new try/catch block and registers it with v8.  Note that
    * all TryCatch blocks should be stack allocated because the memory
    * location itself is compared against JavaScript try/catch blocks.
    */
   // TODO(dcarney): deprecate.
@@ skipping 1858 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_