diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageOverflowException.java b/msgpack-core/src/main/java/org/msgpack/core/MessageOverflowException.java
index 2190a34c1..ff63ba588 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/MessageOverflowException.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/MessageOverflowException.java
@@ -1,7 +1,9 @@
 package org.msgpack.core;
 
 /**
- * Created on 5/28/14.
+ * Thrown when converting a message into a type that causes truncation or rounding.
+ * For example, {@link org.msgpack.value.NumberValue#asInt()} throws this error if
+ * it is a long value more than {@link java.lang.Integer#MAX_VALUE}.
  */
 public class MessageOverflowException extends MessageTypeException {
 
diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
index 3fb76d0a1..83f16c78e 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
@@ -766,7 +766,7 @@ public long unpackLong() throws IOException {
             case Code.UINT32: // unsigned int 32
                 int u32 = readInt();
                 if(u32 < 0) {
-                    return (long) (u32 & 0x7fffffff) + 0x80000000L;
+                    return u32 & 0xffffffffL;
                 } else {
                     return (long) u32;
                 }
@@ -808,7 +808,7 @@ public BigInteger unpackBigInteger() throws IOException {
             case Code.UINT32: // unsigned int 32
                 int u32 = readInt();
                 if(u32 < 0) {
-                    return BigInteger.valueOf((long) (u32 & 0x7fffffff) + 0x80000000L);
+                    return BigInteger.valueOf(u32 & 0xffffffffL);
                 } else {
                     return BigInteger.valueOf((long) u32);
                 }
@@ -884,7 +884,7 @@ public void unpackInteger(IntegerHolder holder) throws IOException {
             case Code.UINT32: // unsigned int 32
                 int u32 = readInt();
                 if(u32 < 0) {
-                    holder.setLong((long) (u32 & 0x7fffffff) + 0x80000000L);
+                    holder.setLong(u32 & 0xffffffffL);
                 } else {
                     holder.setInt(u32);
                 }
@@ -1229,7 +1229,7 @@ private static MessageIntegerOverflowException overflowU16(short u16) {
     }
 
     private static MessageIntegerOverflowException overflowU32(int u32) {
-        BigInteger bi = BigInteger.valueOf((long) (u32 & 0x7fffffff) + 0x80000000L);
+        BigInteger bi = BigInteger.valueOf(u32 & 0xffffffffL);
         return new MessageIntegerOverflowException(bi);
     }
 
@@ -1254,7 +1254,7 @@ private static MessageIntegerOverflowException overflowI64(long i64) {
     }
 
     private static MessageSizeException overflowU32Size(int u32) {
-        long lv = (long) (u32 & 0x7fffffff) + 0x80000000L;
+        long lv = u32 & 0xffffffffL;
         return new MessageSizeException(lv);
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java b/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java
index be409e932..9b72767c5 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java
@@ -181,11 +181,11 @@ public static void readAndWriteFile() throws IOException {
             switch(format.getValueType()) {
                 case NIL:
                     Value nil = v.get();
-                    nil.isNil(); // true
+                    nil.isNilValue(); // true
                     System.out.println("read nil");
                     break;
                 case BOOLEAN:
-                    boolean b = v.get().asBoolean().toBoolean();
+                    boolean b = v.get().asBooleanValue().toBoolean();
                     System.out.println("read boolean: " + b);
                     break;
                 case INTEGER:
@@ -206,22 +206,22 @@ public static void readAndWriteFile() throws IOException {
                     System.out.println("read float: " + d);
                     break;
                 case STRING:
-                    String s = v.get().asString().toString();
+                    String s = v.get().asStringValue().toString();
                     System.out.println("read string: " + s);
                     break;
                 case BINARY:
                     // Message buffer is an efficient byte buffer
-                    MessageBuffer mb = v.get().asBinary().toMessageBuffer();
+                    MessageBuffer mb = v.get().asBinaryValue().toMessageBuffer();
                     System.out.println("read binary: " + mb.toHexString(0, mb.size()));
                     break;
                 case ARRAY:
                     ArrayValue arr = v.get().asArrayValue();
-                    for(ValueRef a : arr) {
+                    for(Value a : arr) {
                         System.out.println("read array element: " + a);
                     }
                     break;
                 case EXTENDED:
-                    ExtendedValue ev = v.get().asExtended();
+                    ExtendedValue ev = v.get().asExtendedValue();
                     int extType = ev.getExtType();
                     byte[] extValue = ev.toByteArray();
                     break;
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ArrayCursor.java b/msgpack-core/src/main/java/org/msgpack/value/ArrayCursor.java
index d491ba9c8..a853dd0ad 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/ArrayCursor.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/ArrayCursor.java
@@ -5,11 +5,11 @@
 /**
  * Created on 6/16/14.
  */
-public interface ArrayCursor extends ValueRef, Iterable<ValueRef> {
+public interface ArrayCursor extends Value, Iterable<Value> {
     public int size();
 
     public boolean hasNext();
-    public ValueRef next();
+    public Value next();
     public void skip();
 
     /**
@@ -17,8 +17,8 @@ public interface ArrayCursor extends ValueRef, Iterable<ValueRef> {
      */
     public void skipAll();
 
-    public Iterator<ValueRef> iterator();
+    public Iterator<Value> iterator();
 
-    public ArrayValue toValue();
+    public ArrayValue toImmutable();
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ArrayValue.java b/msgpack-core/src/main/java/org/msgpack/value/ArrayValue.java
index 570b533af..c161d8cb7 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/ArrayValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/ArrayValue.java
@@ -9,15 +9,15 @@
  * Implementation note: We do not implement List<Value> interface here, because
  * we cannot reuse AbstractList and AbstractValue implementations simultaneously since
  * Java does not support mixin of classes. Instead, it provides {@link #iterator} or
- * {@link #toValueArray()} methods to traverse the array contents.
+ * {@link #toArray()} methods to traverse the array contents.
  */
 public interface ArrayValue extends Value, ArrayCursor {
 
-    public Value[] toValueArray();
+    public Value[] toArray();
 
     public Value get(int index);
     public Value apply(int index);
 
-    public ArrayValue toValue();
+    public ArrayValue toImmutable();
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Cursor.java b/msgpack-core/src/main/java/org/msgpack/value/Cursor.java
index 09fa50e5f..935298ecd 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/Cursor.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/Cursor.java
@@ -5,7 +5,9 @@
 import java.util.Iterator;
 
 /**
- * Cursor for traversing a stream of message-packed values
+ * Cursor for traversing a stream of message-packed values.
+ * Returned value might be changed for efficiency. To retrieving an immutable value,
+ * call {@link org.msgpack.value.Value#toImmutable()} after retrieving a value.
  */
 public interface Cursor extends Iterator<Value>, Closeable {
 
@@ -16,14 +18,7 @@ public interface Cursor extends Iterator<Value>, Closeable {
     public boolean hasNext();
 
     /**
-     * Returns a reference to the value, then proceeds the cursor.
-     * The returned reference is valid until {@link #hasNext()} is called.
-     * @return
-     */
-    public ValueRef nextRef();
-
-    /**
-     * Returns the materialized value of the referenced value, then proceeds the cursor.
+     * Returns the next value, then proceeds the cursor.
      * @return
      */
     public Value next();
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ExtendedValue.java b/msgpack-core/src/main/java/org/msgpack/value/ExtendedValue.java
index 9d4b47a16..8e8c49fae 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/ExtendedValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/ExtendedValue.java
@@ -1,9 +1,9 @@
 package org.msgpack.value;
 
 /**
-* Created on 5/30/14.
+* ExtendedValue interface
 */
 public interface ExtendedValue extends RawValue {
     public int getExtType();
-    public ExtendedValue toValue();
+    public ExtendedValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/FloatValue.java b/msgpack-core/src/main/java/org/msgpack/value/FloatValue.java
index 3e5dda745..cd95b8ba7 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/FloatValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/FloatValue.java
@@ -1,8 +1,8 @@
 package org.msgpack.value;
 
 /**
-* Created on 5/30/14.
+* FloatValue interface
 */
 public interface FloatValue extends NumberValue {
-    FloatValue toValue();
+    FloatValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/IntegerValue.java b/msgpack-core/src/main/java/org/msgpack/value/IntegerValue.java
index 4299b42ad..cca25af7e 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/IntegerValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/IntegerValue.java
@@ -1,8 +1,8 @@
 package org.msgpack.value;
 
 /**
-* Created on 5/30/14.
+* IntegerValue interface
 */
 public interface IntegerValue extends NumberValue {
-    IntegerValue toValue();
+    IntegerValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/KeyValuePair.java b/msgpack-core/src/main/java/org/msgpack/value/KeyValuePair.java
new file mode 100644
index 000000000..ee7bdffdc
--- /dev/null
+++ b/msgpack-core/src/main/java/org/msgpack/value/KeyValuePair.java
@@ -0,0 +1,14 @@
+package org.msgpack.value;
+
+/**
+*
+*/
+public class KeyValuePair {
+    public final Value key;
+    public final Value value;
+
+    public KeyValuePair(Value key, Value value) {
+        this.key = key;
+        this.value = value;
+    }
+}
diff --git a/msgpack-core/src/main/java/org/msgpack/value/MapCursor.java b/msgpack-core/src/main/java/org/msgpack/value/MapCursor.java
index beae8cd54..4ea8e6e3f 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/MapCursor.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/MapCursor.java
@@ -1,12 +1,10 @@
 package org.msgpack.value;
 
-import java.util.Iterator;
-import java.util.Map;
 
 /**
  * Cursor for traversing map value entries. This cursor reports a sequence of key and value pairs.
  */
-public interface MapCursor extends ValueRef {
+public interface MapCursor extends Value {
     public int size();
 
     /**
@@ -16,20 +14,20 @@ public interface MapCursor extends ValueRef {
     public boolean hasNext();
 
     /**
-     * Retrieves a reference to the next key or value.
+     * Retrieves the next key and value.
      * @return
      */
-    public ValueRef nextKeyOrValue();
+    public KeyValuePair next();
 
     /**
-     * Skips a next key or value
+     * Skips a next key-value pair
      */
-    public void skipKeyOrValue();
+    public void skip();
 
     /**
      * Skips all of the remaining keys and values.
      */
     public void skipAll();
 
-    MapValue toValue();
+    public MapValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/MapValue.java b/msgpack-core/src/main/java/org/msgpack/value/MapValue.java
index ea67fdad6..2adf31cd4 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/MapValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/MapValue.java
@@ -3,11 +3,12 @@
 import java.util.Map;
 
 /**
-* Created on 5/30/14.
+* MapValue interface
 */
 public interface MapValue extends Value, MapCursor {
-    public Value[] toKeyValueSeq();
+    public Value[] toKeyValueArray();
+    public KeyValuePair[] toArray();
     public Map<Value, Value> toMap();
 
-    public MapValue toValue();
+    public MapValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/NilValue.java b/msgpack-core/src/main/java/org/msgpack/value/NilValue.java
index 4c8c39beb..7818d3fb4 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/NilValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/NilValue.java
@@ -4,5 +4,5 @@
  * References to values
  */
 public interface NilValue extends Value {
-    NilValue toValue();
+    NilValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java b/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java
index 38952fcc5..cfa5ba9a9 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java
@@ -5,7 +5,7 @@
 import java.math.BigInteger;
 
 /**
-* Created on 5/30/14.
+* NumberValue interface
 */
 public interface NumberValue extends Value {
 
@@ -60,11 +60,11 @@ public interface NumberValue extends Value {
      */
     public BigInteger toBigInteger();
     /**
-     * Convert this value into a float value
+     * Convert this value into a 32-bit float
      */
     public float toFloat();
     /**
-     * Convert this value into a double value
+     * Convert this value into a 64-bit double
      */
     public double toDouble();
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/RawValue.java b/msgpack-core/src/main/java/org/msgpack/value/RawValue.java
index 720ecbd36..01bf39e5d 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/RawValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/RawValue.java
@@ -1,6 +1,5 @@
 package org.msgpack.value;
 
-import org.msgpack.core.MessageStringCodingException;
 import org.msgpack.core.buffer.MessageBuffer;
 
 import java.nio.ByteBuffer;
@@ -9,12 +8,27 @@
  * Base type of StringValue, BinaryValue and ExtendedValue
  */
 public interface RawValue extends Value {
+
+    /**
+     * Returns byte array representation of this value
+     * @return
+     */
     public byte[] toByteArray();
+
+    /**
+     * Returns ByteBuffer representation of this value
+     * @return
+     */
     public ByteBuffer toByteBuffer();
+
+    /**
+     * Returns MessageBuffer representation of this value
+     * @return
+     */
     public MessageBuffer toMessageBuffer();
 
     @Override
     public String toString();
 
-    public RawValue toValue();
+    public RawValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/StringValue.java b/msgpack-core/src/main/java/org/msgpack/value/StringValue.java
index 35315f14d..ebf224f61 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/StringValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/StringValue.java
@@ -1,8 +1,8 @@
 package org.msgpack.value;
 
 /**
- * Created on 5/30/14.
+ * StringValue interface
  */
 public interface StringValue extends RawValue {
-    public StringValue toValue();
+    public StringValue toImmutable();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Value.java b/msgpack-core/src/main/java/org/msgpack/value/Value.java
index 0cf02453c..5e9d4b165 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/Value.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/Value.java
@@ -15,15 +15,65 @@
 //
 package org.msgpack.value;
 
+import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageTypeException;
 
-import org.msgpack.core.*;
+import java.io.IOException;
 
 /**
- * Value is a holder of a message-packed value.
+ * Value is an object representation of a message pack value.
  */
-public interface Value extends ValueRef {
+public interface Value {
 
+    public ValueType getValueType();
+
+    public NilValue asNilValue() throws MessageTypeException;
+    public BooleanValue asBooleanValue() throws MessageTypeException;
+    public NumberValue asNumberValue() throws MessageTypeException;
+    public IntegerValue asIntegerValue() throws MessageTypeException;
+    public FloatValue asFloatValue() throws MessageTypeException;
+    public BinaryValue asBinaryValue() throws MessageTypeException;
+    public StringValue asStringValue() throws MessageTypeException;
+    public RawValue asRawValue() throws MessageTypeException;
+    public ExtendedValue asExtendedValue() throws MessageTypeException;
     public ArrayValue asArrayValue() throws MessageTypeException;
     public MapValue asMapValue() throws MessageTypeException;
 
+    public boolean isNilValue();
+    public boolean isBooleanValue();
+    public boolean isNumberValue();
+    public boolean isIntegerValue();
+    public boolean isFloatValue();
+    public boolean isBinaryValue();
+    public boolean isStringValue();
+    public boolean isRawValue();
+    public boolean isArrayValue();
+    public boolean isMapValue();
+    public boolean isExtendedValue();
+
+    /**
+     * Write this value into the specified packer
+     * @param packer
+     * @throws IOException
+     */
+    public void writeTo(MessagePacker packer) throws IOException;
+
+    /**
+     * Accepting a visitor
+     * @param visitor
+     */
+    public void accept(ValueVisitor visitor);
+
+    /**
+     * Create an immutable representation of this value. If this value is already immutable, it returns self
+     * @return
+     */
+    public Value toImmutable();
+
+    /**
+     * Test whether this value is an immutable or not
+     * @return true if this value is an immutable object, otherwise false.
+     */
+    public boolean isImmutable();
+
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java b/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java
index d1b1a5c61..1d2d71d7a 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java
@@ -15,10 +15,9 @@
 //
 package org.msgpack.value;
 
-import org.msgpack.value.holder.FloatHolder;
-import org.msgpack.value.holder.IntegerHolder;
 import org.msgpack.value.impl.*;
 
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -124,6 +123,40 @@ public static <K extends Value, V extends Value> MapValue newMap(Map<K, V> map)
         return newMap(keyValueSequence);
     }
 
+    public static MapValue newMap(KeyValuePair... pairs) {
+        MapValueBuilder b = new MapValueBuilder();
+        for(KeyValuePair p : pairs) {
+            b.put(p);
+        }
+        return b.build();
+    }
+
+
+    public static MapValueBuilder newMapBuilder() {
+        return new MapValueBuilder();
+    }
+
+    public static KeyValuePair newPair(Value key, Value value) {
+        return new KeyValuePair(key, value);
+    }
+
+    public static class MapValueBuilder {
+        private Map<Value, Value> map = new HashMap<Value, Value>();
+        public MapValueBuilder() {}
+
+        public MapValue build() {
+            return newMap(map);
+        }
+
+        public void put(KeyValuePair pair) {
+            put(pair.key, pair.value);
+        }
+
+        public void put(Value key, Value value) {
+            map.put(key, value);
+        }
+    }
+
     public static MapValue newMap(Value[] keyValueSequence) {
         if (keyValueSequence.length == 0) {
             return MapValueImpl.empty();
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ValueRef.java b/msgpack-core/src/main/java/org/msgpack/value/ValueRef.java
deleted file mode 100644
index 0043e4392..000000000
--- a/msgpack-core/src/main/java/org/msgpack/value/ValueRef.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package org.msgpack.value;
-
-import org.msgpack.core.MessagePacker;
-import org.msgpack.core.MessageTypeException;
-
-import java.io.IOException;
-
-/**
- * Reference to the value
- */
-public interface ValueRef {
-    public ValueType getValueType();
-
-    public NilValue asNil() throws MessageTypeException;
-    public BooleanValue asBoolean() throws MessageTypeException;
-    public NumberValue asNumber() throws MessageTypeException;
-    public IntegerValue asInteger() throws MessageTypeException;
-    public FloatValue asFloat() throws MessageTypeException;
-    public BinaryValue asBinary() throws MessageTypeException;
-    public StringValue asString() throws MessageTypeException;
-    public RawValue asRaw() throws MessageTypeException;
-    public ExtendedValue asExtended() throws MessageTypeException;
-
-    public ArrayCursor getArrayCursor() throws MessageTypeException;
-    public MapCursor getMapCursor() throws MessageTypeException;
-
-    public boolean isNil();
-    public boolean isBoolean();
-    public boolean isNumber();
-    public boolean isInteger();
-    public boolean isFloat();
-    public boolean isBinary();
-    public boolean isString();
-    public boolean isRaw();
-    public boolean isArray();
-    public boolean isMap();
-    public boolean isExtended();
-
-    public void writeTo(MessagePacker packer) throws IOException;
-
-    public void accept(ValueVisitor visitor);
-
-    /**
-     * Create an immutable value from this reference
-     * @return
-     */
-    public Value toValue();
-
-    /**
-     * Test whether this value is a reference of not.
-     * @return true if this value is reference, otherwise false.
-     */
-    public boolean isRef();
-}
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ValueVisitor.java b/msgpack-core/src/main/java/org/msgpack/value/ValueVisitor.java
index 22436d30a..c7cb18f92 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/ValueVisitor.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/ValueVisitor.java
@@ -30,5 +30,9 @@ public interface ValueVisitor {
     public void visitMap(MapValue v);
     public void visitExtended(ExtendedValue v);
 
+    /**
+     * Visitor can use this method to handle an exception occurred while visiting a value
+     * @param e
+     */
     public void onError(Exception e);
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/holder/ExtHolder.java b/msgpack-core/src/main/java/org/msgpack/value/holder/ExtHolder.java
index b5a8eaf58..1dbe44e0c 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/holder/ExtHolder.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/holder/ExtHolder.java
@@ -6,15 +6,14 @@
 import org.msgpack.core.buffer.MessageBuffer;
 import org.msgpack.value.*;
 import org.msgpack.value.impl.AbstractValue;
-import org.msgpack.value.impl.AbstractValueRef;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
 /**
- * Created on 6/13/14.
+ * ExtendedValue holder
  */
-public class ExtHolder extends AbstractValueRef implements ExtendedValue {
+public class ExtHolder extends AbstractValue implements ExtendedValue {
 
     private int extType;
     private MessageBuffer buffer;
@@ -45,7 +44,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitExtended(this);
     }
     @Override
-    public ExtendedValue toValue() {
+    public ExtendedValue toImmutable() {
         // clone the buffer contents
         return ValueFactory.newExtendedValue(extType, buffer.toByteArray());
     }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/holder/FloatHolder.java b/msgpack-core/src/main/java/org/msgpack/value/holder/FloatHolder.java
index a26e3efcc..fa64c095c 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/holder/FloatHolder.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/holder/FloatHolder.java
@@ -5,7 +5,6 @@
 import org.msgpack.core.MessagePacker;
 import org.msgpack.value.*;
 import org.msgpack.value.impl.AbstractValue;
-import org.msgpack.value.impl.AbstractValueRef;
 
 import java.io.IOException;
 import java.math.BigDecimal;
@@ -14,7 +13,7 @@
 /**
  * Created on 6/3/14.
  */
-public class FloatHolder extends AbstractValueRef implements FloatValue {
+public class FloatHolder extends AbstractValue implements FloatValue {
 
     public static enum Type {
         FLOAT,
@@ -132,7 +131,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitFloat(this);
     }
     @Override
-    public FloatValue toValue() {
+    public FloatValue toImmutable() {
         switch(tpe) {
             case FLOAT:
                 return ValueFactory.newFloat(toFloat());
diff --git a/msgpack-core/src/main/java/org/msgpack/value/holder/IntegerHolder.java b/msgpack-core/src/main/java/org/msgpack/value/holder/IntegerHolder.java
index 6cea891bb..11abe0f60 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/holder/IntegerHolder.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/holder/IntegerHolder.java
@@ -5,7 +5,6 @@
 import org.msgpack.core.MessageTypeException;
 import org.msgpack.value.*;
 import org.msgpack.value.impl.AbstractValue;
-import org.msgpack.value.impl.AbstractValueRef;
 
 import java.io.IOException;
 import java.math.BigInteger;
@@ -14,7 +13,7 @@
 /**
  * Union of integer values
  */
-public class IntegerHolder extends AbstractValueRef implements IntegerValue {
+public class IntegerHolder extends AbstractValue implements IntegerValue {
 
     @Override
     public ValueType getValueType() {
@@ -22,7 +21,7 @@ public ValueType getValueType() {
     }
     @Override
     public void writeTo(MessagePacker packer) throws IOException {
-        switch(tpe) {
+        switch(type) {
             case BIG_INTEGER:
                 packer.packBigInteger(biValue);
                 break;
@@ -33,7 +32,7 @@ public void writeTo(MessagePacker packer) throws IOException {
     }
 
     @Override
-    public IntegerValue asInteger() throws MessageTypeException {
+    public IntegerValue asIntegerValue() throws MessageTypeException {
         return this;
     }
 
@@ -43,8 +42,8 @@ public void accept(ValueVisitor visitor) {
     }
 
     @Override
-    public IntegerValue toValue() {
-        switch(tpe){
+    public IntegerValue toImmutable() {
+        switch(type){
             case BYTE:
                 return ValueFactory.newByte(toByte());
             case SHORT:
@@ -68,32 +67,32 @@ public static enum Type {
         BIG_INTEGER
     }
 
-    private Type tpe;
+    private Type type;
     private long longValue;
     private BigInteger biValue;
 
     public Type getType() {
-        return tpe;
+        return type;
     }
 
     public void setByte(byte v){
-        tpe = Type.BYTE;
+        type = Type.BYTE;
         longValue = v;
     }
     public void setShort(short v) {
-        tpe = Type.SHORT;
+        type = Type.SHORT;
         longValue = v;
     }
     public void setInt(int v) {
-        tpe = Type.INT;
+        type = Type.INT;
         longValue = v;
     }
     public void setLong(long v) {
-        tpe = Type.LONG;
+        type = Type.LONG;
         longValue = v;
     }
     public void setBigInteger(BigInteger v) {
-        tpe = Type.BIG_INTEGER;
+        type = Type.BIG_INTEGER;
         biValue = v;
     }
 
@@ -102,24 +101,24 @@ private RuntimeException failure() {
     }
 
     public boolean isBigInteger() {
-        return tpe == Type.BIG_INTEGER;
+        return type == Type.BIG_INTEGER;
     }
 
     @Override
     public boolean isValidByte() {
-        return tpe == Type.BYTE;
+        return type == Type.BYTE;
     }
     @Override
     public boolean isValidShort() {
-        return tpe.ordinal() <= Type.SHORT.ordinal();
+        return type.ordinal() <= Type.SHORT.ordinal();
     }
     @Override
     public boolean isValidInt() {
-        return tpe.ordinal() <= Type.INT.ordinal();
+        return type.ordinal() <= Type.INT.ordinal();
     }
     @Override
     public boolean isValidLong() {
-        return tpe.ordinal() <= Type.LONG.ordinal();
+        return type.ordinal() <= Type.LONG.ordinal();
     }
 
     @Override
@@ -127,22 +126,27 @@ public boolean isWhole() {
         return true;
     }
 
+    @Override
     public byte toByte() {
         return isBigInteger() ? biValue.byteValue() : (byte) longValue;
     }
 
+    @Override
     public short toShort() {
         return isBigInteger() ? biValue.shortValue() : (short) longValue;
     }
 
+    @Override
     public int toInt() {
         return isBigInteger() ? biValue.intValue() : (int) longValue;
     }
 
+    @Override
     public long toLong(){
         return isBigInteger() ? biValue.longValue() : longValue;
     }
 
+    @Override
     public BigInteger toBigInteger() {
         return isBigInteger() ? biValue : BigInteger.valueOf(longValue);
     }
@@ -158,7 +162,7 @@ public double toDouble() {
 
     @Override
     public byte asByte() throws MessageIntegerOverflowException {
-        switch(tpe) {
+        switch(type) {
             case BYTE:
                 return (byte) longValue;
             case SHORT:
@@ -185,7 +189,7 @@ public byte asByte() throws MessageIntegerOverflowException {
 
     @Override
     public short asShort() throws MessageIntegerOverflowException {
-        switch(tpe) {
+        switch(type) {
             case BYTE:
             case SHORT:
                 return (short) longValue;
@@ -212,7 +216,7 @@ public short asShort() throws MessageIntegerOverflowException {
 
     @Override
     public int asInt() throws MessageIntegerOverflowException {
-        switch(tpe) {
+        switch(type) {
             case BYTE:
             case SHORT:
             case INT:
@@ -256,7 +260,14 @@ public BigInteger asBigInteger() {
 
     @Override
     public int hashCode() {
-        return isBigInteger() ? biValue.hashCode() : (int) longValue;
+        int hash = 0;
+        if(isBigInteger()) {
+            hash = biValue.hashCode();
+        }
+        else {
+            hash = (int)((longValue >>> 32) * 31 + longValue & 0xFFFFFFFF);
+        }
+        return hash;
     }
 
     @Override
diff --git a/msgpack-core/src/main/java/org/msgpack/value/holder/RawHolder.java b/msgpack-core/src/main/java/org/msgpack/value/holder/RawHolder.java
index 371589957..1edc0d6e8 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/holder/RawHolder.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/holder/RawHolder.java
@@ -5,7 +5,7 @@
 import org.msgpack.core.MessageStringCodingException;
 import org.msgpack.core.buffer.MessageBuffer;
 import org.msgpack.value.*;
-import org.msgpack.value.impl.AbstractValueRef;
+import org.msgpack.value.impl.AbstractValue;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -13,7 +13,7 @@
 import static org.msgpack.core.MessagePackException.UNREACHABLE;
 
 
-class RawHolderImpl extends AbstractValueRef implements RawValue {
+class RawHolderImpl extends AbstractValue implements RawValue {
 
     public static enum Type {
         STRING,
@@ -50,6 +50,7 @@ public byte[] toByteArray() {
     public ByteBuffer toByteBuffer() {
         switch(tpe) {
             case STRING:
+            case BINARY:
                 return buf.toByteBuffer();
             default:
                 throw UNREACHABLE;
@@ -104,10 +105,10 @@ public void writeTo(MessagePacker packer) throws IOException {
     public void accept(ValueVisitor visitor) {
         switch(tpe) {
             case STRING:
-                visitor.visitString(this.asString());
+                visitor.visitString(this.asStringValue());
                 break;
             case BINARY:
-                visitor.visitBinary(this.asBinary());
+                visitor.visitBinary(this.asBinaryValue());
                 break;
             default:
                 throw UNREACHABLE;
@@ -115,7 +116,7 @@ public void accept(ValueVisitor visitor) {
     }
 
     @Override
-    public RawValue toValue() {
+    public RawValue toImmutable() {
         switch(tpe) {
             case STRING:
                 return ValueFactory.newRawString(buf.toByteArray());
@@ -135,19 +136,21 @@ public RawValue toValue() {
 public class RawHolder extends RawHolderImpl {
 
     private static class StringValueWrap extends RawHolderImpl implements StringValue {
-        public StringValue toValue() {
+        @Override
+        public StringValue toImmutable() {
             return ValueFactory.newRawString(buf.toByteArray());
         }
     }
 
     private static class BinaryValueWrap extends RawHolderImpl implements BinaryValue {
+        @Override
         public BinaryValue toValue() {
             return ValueFactory.newBinary(buf.toByteArray());
         }
     }
 
-    private StringValueWrap stringWrap = new StringValueWrap();
-    private BinaryValueWrap binaryWrap = new BinaryValueWrap();
+    private final StringValueWrap stringWrap = new StringValueWrap();
+    private final BinaryValueWrap binaryWrap = new BinaryValueWrap();
 
     @Override
     public void setString(MessageBuffer buf) {
@@ -180,6 +183,7 @@ public byte[] toByteArray() {
     public ByteBuffer toByteBuffer() {
         switch(tpe) {
             case STRING:
+            case BINARY:
                 return buf.toByteBuffer();
             default:
                 throw UNREACHABLE;
@@ -234,10 +238,10 @@ public void writeTo(MessagePacker packer) throws IOException {
     public void accept(ValueVisitor visitor) {
         switch(tpe) {
             case STRING:
-                visitor.visitString(this.asString());
+                visitor.visitString(this.asStringValue());
                 break;
             case BINARY:
-                visitor.visitBinary(this.asBinary());
+                visitor.visitBinary(this.asBinaryValue());
                 break;
             default:
                 throw UNREACHABLE;
@@ -245,7 +249,7 @@ public void accept(ValueVisitor visitor) {
     }
     
     @Override
-    public RawValue toValue() {
+    public RawValue toImmutable() {
         switch(tpe) {
             case STRING:
                 return ValueFactory.newRawString(buf.toByteArray());
@@ -258,12 +262,12 @@ public RawValue toValue() {
 
 
     @Override
-    public StringValue asString() {
+    public StringValue asStringValue() {
         return stringWrap;
     }
 
     @Override
-    public BinaryValue asBinary() {
+    public BinaryValue asBinaryValue() {
         return binaryWrap;
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/holder/ValueHolder.java b/msgpack-core/src/main/java/org/msgpack/value/holder/ValueHolder.java
index 686bb710a..d178a7116 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/holder/ValueHolder.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/holder/ValueHolder.java
@@ -2,7 +2,6 @@
 
 import org.msgpack.core.MessageUnpacker;
 import org.msgpack.core.buffer.MessageBuffer;
-import org.msgpack.value.ValueRef;
 import org.msgpack.value.impl.ArrayCursorImpl;
 import org.msgpack.value.Value;
 import org.msgpack.value.ValueFactory;
@@ -11,7 +10,6 @@
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.util.ArrayDeque;
 
 import static org.msgpack.core.MessagePackException.UNREACHABLE;
 
@@ -27,15 +25,7 @@ public class ValueHolder {
     private ExtHolder extHolder = new ExtHolder();
     private ArrayCursorImpl arrayCursor;
     private MapCursorImpl mapCursor;
-    private ValueRef currentRef;
-
-    public ValueRef getRef() {
-        if(currentRef == null) {
-            throw new IllegalStateException("no value is set to this holder");
-        }
-
-        return currentRef;
-    }
+    private Value current;
 
     public Value get() {
         switch(vt) {
@@ -46,17 +36,16 @@ public Value get() {
             case ARRAY:
             case MAP:
             case EXTENDED:
-                return getRef().toValue();
             case STRING:
-                return ValueFactory.newRawString(cloneBuffer(rawHolder.getBuffer()));
             case BINARY:
-                return ValueFactory.newBinary(cloneBuffer(rawHolder.getBuffer()));
+                return current;
+//                return ValueFactory.newRawString(cloneBuffer(rawHolder.getBuffer()));
+//                return ValueFactory.newBinary(cloneBuffer(rawHolder.getBuffer()));
             default:
                 throw UNREACHABLE;
         }
     }
 
-
     private static ByteBuffer cloneBuffer(MessageBuffer buffer) {
         return ByteBuffer.wrap(buffer.toByteArray());
     }
@@ -71,40 +60,40 @@ public FloatHolder getFloatHolder() {
 
     public void setBoolean(boolean v) {
         vt = ValueType.BOOLEAN;
-        currentRef = ValueFactory.newBoolean(v);
+        current = ValueFactory.newBoolean(v);
     }
 
     public void setNil() {
         vt = ValueType.NIL;
-        currentRef = ValueFactory.nilValue();
+        current = ValueFactory.nilValue();
     }
 
     public void setString(MessageBuffer rawString) {
         vt = ValueType.STRING;
         rawHolder.setString(rawString);
-        currentRef = rawHolder.asString();
+        current = rawHolder.asStringValue();
     }
 
     public void setBinary(MessageBuffer b) {
         vt = ValueType.BINARY;
         rawHolder.setBinary(b);
-        currentRef = rawHolder.asBinary();
+        current = rawHolder.asBinaryValue();
     }
 
     public void setToInteger() {
         vt = ValueType.INTEGER;
-        currentRef = integerHolder;
+        current = integerHolder;
     }
 
     public void setToFloat() {
         vt = ValueType.FLOAT;
-        currentRef = floatHolder;
+        current = floatHolder;
     }
 
     public void setExt(int extType, MessageBuffer b) {
         vt = ValueType.EXTENDED;
         extHolder.setExtType(extType, b);
-        currentRef = extHolder;
+        current = extHolder;
     }
 
     public void prepareArrayCursor(MessageUnpacker unpacker) throws IOException {
@@ -113,7 +102,7 @@ public void prepareArrayCursor(MessageUnpacker unpacker) throws IOException {
         // TODO reusing cursor instances
         arrayCursor = new ArrayCursorImpl(new ValueHolder());
         arrayCursor.reset(unpacker);
-        currentRef = arrayCursor;
+        current = arrayCursor;
     }
 
     public void prepareMapCursor(MessageUnpacker unpacker) throws IOException {
@@ -122,7 +111,7 @@ public void prepareMapCursor(MessageUnpacker unpacker) throws IOException {
         // TODO reusing cursor instances
         mapCursor = new MapCursorImpl(new ValueHolder());
         mapCursor.reset(unpacker);
-        currentRef = mapCursor;
+        current = mapCursor;
     }
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValue.java b/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValue.java
index c74dc38a7..744da2018 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValue.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValue.java
@@ -7,9 +7,48 @@
 /**
 * Base implementation of MessagePackValue
 */
-public abstract class AbstractValue extends AbstractValueRef implements Value {
+public abstract class AbstractValue implements Value {
 
-    @Override
-    public boolean isRef() { return false; }
+    public boolean isImmutable() { return true; }
+
+    protected static int NUMBER_TYPE_MASK = (1 << ValueType.INTEGER.ordinal())
+        | (1 << ValueType.FLOAT.ordinal());
+    protected static int RAW_TYPE_MASK = (1 << ValueType.STRING.ordinal())
+        | (1 << ValueType.BINARY.ordinal());
+
+    protected <E extends Value> E as(Class<E> valueClass, ValueType vt) {
+        return as(valueClass, 1 << vt.ordinal());
+    }
+    protected <E extends Value> E as(Class<E> valueClass, int bitMask) {
+        if(this.getValueType() == null)
+            throw new MessageTypeException("This value points to nothing");
+        if(!this.getValueType().isTypeOf(bitMask))
+            throw new MessageTypeException(String.format("Expected %s, but %s", valueClass.getSimpleName(), this.getValueType()));
+        return valueClass.cast(this);
+    }
+
+    public NilValue asNilValue() throws MessageTypeException { return as(NilValue.class, ValueType.NIL); }
+    public BooleanValue asBooleanValue() throws MessageTypeException{ return as(BooleanValue.class, ValueType.BOOLEAN); }
+    public NumberValue asNumberValue() throws MessageTypeException { return as(NumberValue.class, NUMBER_TYPE_MASK); }
+    public IntegerValue asIntegerValue() throws MessageTypeException { return as(IntegerValue.class, ValueType.INTEGER); }
+    public FloatValue asFloatValue() throws MessageTypeException { return as(FloatValue.class, ValueType.FLOAT); }
+    public BinaryValue asBinaryValue() throws MessageTypeException { return as(BinaryValue.class, ValueType.BINARY); }
+    public StringValue asStringValue() throws MessageTypeException { return as(StringValue.class, ValueType.STRING); }
+    public RawValue asRawValue() throws MessageTypeException { return as(RawValue.class, RAW_TYPE_MASK); }
+    public ArrayValue asArrayValue() throws MessageTypeException { return as(ArrayValue.class, ValueType.ARRAY); }
+    public MapValue asMapValue() throws MessageTypeException { return as(MapValue.class, ValueType.MAP); }
+    public ExtendedValue asExtendedValue() throws MessageTypeException { return as(ExtendedValue.class, ValueType.EXTENDED); }
+
+    public boolean isNilValue() { return getValueType().isNilType(); }
+    public boolean isBooleanValue() { return getValueType().isBooleanType(); }
+    public boolean isNumberValue() { return getValueType().isNumberType(); }
+    public boolean isIntegerValue() { return getValueType().isIntegerType(); }
+    public boolean isFloatValue() { return getValueType().isFloatType(); }
+    public boolean isBinaryValue() { return getValueType().isBinaryType(); }
+    public boolean isStringValue() { return getValueType().isStringType(); }
+    public boolean isRawValue() { return getValueType().isRawType(); }
+    public boolean isArrayValue() { return getValueType().isArrayType(); }
+    public boolean isMapValue() { return getValueType().isMapType(); }
+    public boolean isExtendedValue() { return getValueType().isExtendedType(); }
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValueRef.java b/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValueRef.java
deleted file mode 100644
index 1e67a6b3c..000000000
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/AbstractValueRef.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package org.msgpack.value.impl;
-
-import org.msgpack.core.MessageTypeException;
-import org.msgpack.value.*;
-
-/**
- * Base implementation of message pack values
- */
-public abstract class AbstractValueRef implements ValueRef {
-
-    public boolean isRef() { return true; }
-
-    protected static int NUMBER_TYPE_MASK = (1 << ValueType.INTEGER.ordinal())
-            | (1 << ValueType.FLOAT.ordinal());
-    protected static int RAW_TYPE_MASK = (1 << ValueType.STRING.ordinal())
-            | (1 << ValueType.BINARY.ordinal());
-
-    protected <E extends Value> E as(Class<E> valueClass, ValueType vt) {
-        return as(valueClass, 1 << vt.ordinal());
-    }
-    protected <E extends Value> E as(Class<E> valueClass, int bitMask) {
-        if(this.getValueType() == null)
-            throw new MessageTypeException("This value points to nothing");
-        if(!this.getValueType().isTypeOf(bitMask))
-            throw new MessageTypeException(String.format("Expected %s, but %s", valueClass.getSimpleName(), this.getValueType()));
-        return valueClass.cast(this);
-    }
-
-    public NilValue asNil() throws MessageTypeException { return as(NilValue.class, ValueType.NIL); }
-    public BooleanValue asBoolean() throws MessageTypeException{ return as(BooleanValue.class, ValueType.BOOLEAN); }
-    public NumberValue asNumber() throws MessageTypeException { return as(NumberValue.class, NUMBER_TYPE_MASK); }
-    public IntegerValue asInteger() throws MessageTypeException { return as(IntegerValue.class, ValueType.INTEGER); }
-    public FloatValue asFloat() throws MessageTypeException { return as(FloatValue.class, ValueType.FLOAT); }
-    public BinaryValue asBinary() throws MessageTypeException { return as(BinaryValue.class, ValueType.BINARY); }
-    public StringValue asString() throws MessageTypeException { return as(StringValue.class, ValueType.STRING); }
-    public RawValue asRaw() throws MessageTypeException { return as(RawValue.class, RAW_TYPE_MASK); }
-    public ArrayValue asArrayValue() throws MessageTypeException { return as(ArrayValue.class, ValueType.ARRAY); }
-    public MapValue asMapValue() throws MessageTypeException { return as(MapValue.class, ValueType.MAP); }
-    public ExtendedValue asExtended() throws MessageTypeException { return as(ExtendedValue.class, ValueType.EXTENDED); }
-
-    @Override
-    public ArrayCursor getArrayCursor() throws MessageTypeException {
-        throw new MessageTypeException("This value is not an array type");
-    }
-    @Override
-    public MapCursor getMapCursor() throws MessageTypeException {
-        throw new MessageTypeException("This value is not a map type");
-    }
-
-    public boolean isNil() { return getValueType().isNilType(); }
-    public boolean isBoolean() { return getValueType().isBooleanType(); }
-    public boolean isNumber() { return getValueType().isNumberType(); }
-    public boolean isInteger() { return getValueType().isIntegerType(); }
-    public boolean isFloat() { return getValueType().isFloatType(); }
-    public boolean isBinary() { return getValueType().isBinaryType(); }
-    public boolean isString() { return getValueType().isStringType(); }
-    public boolean isRaw() { return getValueType().isRawType(); }
-    public boolean isArray() { return getValueType().isArrayType(); }
-    public boolean isMap() { return getValueType().isMapType(); }
-    public boolean isExtended() { return getValueType().isExtendedType(); }
-
-}
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayCursorImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayCursorImpl.java
index 5a5a1676e..edcdc252b 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayCursorImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayCursorImpl.java
@@ -9,9 +9,9 @@
 import java.util.Iterator;
 
 /**
- * Created on 6/16/14.
+ * ArrayCursor implementation
  */
-public class ArrayCursorImpl extends AbstractValueRef implements ArrayCursor {
+public class ArrayCursorImpl extends AbstractValue implements ArrayValue {
 
     private final ValueHolder valueHolder;
     private MessageUnpacker unpacker;
@@ -34,14 +34,14 @@ public int size() {
     }
 
     @Override
-    public Iterator<ValueRef> iterator() {
-        return new Iterator<ValueRef>() {
+    public Iterator<Value> iterator() {
+        return new Iterator<Value>() {
             @Override
             public boolean hasNext() {
                 return ArrayCursorImpl.this.hasNext();
             }
             @Override
-            public ValueRef next() {
+            public Value next() {
                 return ArrayCursorImpl.this.next();
             }
             @Override
@@ -55,11 +55,11 @@ public boolean hasNext() {
         return cursor < arraySize;
     }
 
-    public ValueRef next() {
+    public Value next() {
         try {
             unpacker.unpackValue(valueHolder);
             cursor++;
-            return valueHolder.getRef();
+            return valueHolder.get();
         }
         catch(IOException e) {
             throw new MessageFormatException(e);
@@ -95,32 +95,48 @@ public ValueType getValueType() {
         return ValueType.ARRAY;
     }
 
-    @Override
-    public ArrayCursor getArrayCursor() throws MessageTypeException {
-        return this;
-    }
-
     @Override
     public void writeTo(MessagePacker packer) throws IOException {
         ensureNotTraversed();
         packer.packArrayHeader(arraySize);
-        for(ValueRef v : this) {
-            packer.packValue(v.toValue());
+        for(Value v : this) {
+            packer.packValue(v.toImmutable());
         }
     }
 
     @Override
     public void accept(ValueVisitor visitor) {
-        visitor.visitArray(toValue());
+        visitor.visitArray(toImmutable());
     }
 
     @Override
-    public ArrayValue toValue() {
+    public Value[] toArray() {
+        ensureNotTraversed();
         Value[] arr = new Value[arraySize];
         int i = 0;
-        for(ValueRef v : this) {
-            arr[i++] = v.toValue();
+        for(Value v : this) {
+            arr[i++] = v.toImmutable();
         }
-        return ValueFactory.newArray(arr);
+        return arr;
     }
+
+    @Override
+    public Value get(int index) {
+        throw UNSUPPORTED("get(index) on ArrayCursor is not supported. Use ArrayCursor.toImmutable().");
+    }
+
+    @Override
+    public Value apply(int index) {
+        throw UNSUPPORTED("apply(index) on ArrayCursor is not supported. Use ArrayCursor.toImmutable().");
+    }
+
+    @Override
+    public ArrayValue toImmutable() {
+        return ValueFactory.newArray(toArray());
+
+    }
+
+    @Override
+    public boolean isImmutable() { return false; }
+
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayValueImpl.java
index eda927bed..dfe5a19a1 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/ArrayValueImpl.java
@@ -1,16 +1,18 @@
 package org.msgpack.value.impl;
 
 import org.msgpack.core.MessagePacker;
-import org.msgpack.core.MessageTypeException;
+import org.msgpack.value.ArrayValue;
+import org.msgpack.value.Value;
 import org.msgpack.value.ValueType;
-import org.msgpack.value.*;
+import org.msgpack.value.ValueType;
+import org.msgpack.value.ValueVisitor;
 
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Iterator;
 
 /**
-* Created on 5/30/14.
+* Immutable ArrayValue implementation
 */
 public class ArrayValueImpl extends AbstractValue implements ArrayValue {
     private static ArrayValueImpl EMPTY = new ArrayValueImpl(new Value[0]);
@@ -39,12 +41,6 @@ public ValueType getValueType() {
         return ValueType.ARRAY;
     }
 
-
-    @Override
-    public ArrayCursor getArrayCursor() throws MessageTypeException {
-        return this;
-    }
-
     @Override
     public void writeTo(MessagePacker pk) throws IOException {
         pk.packArrayHeader(array.length);
@@ -57,7 +53,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitArray(this);
     }
     @Override
-    public ArrayValue toValue() {
+    public ArrayValue toImmutable() {
         return this;
     }
 
@@ -70,10 +66,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if(!v.isArray()) {
+        if(!v.isArrayValue()) {
             return false;
         }
-        Value[] other = v.asArrayValue().toValueArray();
+        Value[] other = v.asArrayValue().toArray();
         if(array.length != other.length)
             return false;
 
@@ -123,10 +119,12 @@ public int size() {
     public boolean hasNext() {
         return cursor < array.length;
     }
+
     @Override
-    public ValueRef next() {
+    public Value next() {
         return array[cursor++];
     }
+
     @Override
     public void skip() {
         cursor++;
@@ -138,20 +136,20 @@ public void skipAll() {
         }
     }
 
-    public Value[] toValueArray() {
+    public Value[] toArray() {
         return Arrays.copyOf(array, array.length);
     }
 
     @Override
-    public Iterator<ValueRef> iterator() {
-        return new Iterator<ValueRef>() {
+    public Iterator<Value> iterator() {
+        return new Iterator<Value>() {
             int cursor = 0;
             @Override
             public boolean hasNext() {
                 return cursor < array.length;
             }
             @Override
-            public ValueRef next() {
+            public Value next() {
                 return array[cursor++];
             }
             @Override
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/BigIntegerValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/BigIntegerValueImpl.java
index 85af4a176..fc4340eb9 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/BigIntegerValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/BigIntegerValueImpl.java
@@ -13,8 +13,8 @@
 import static org.msgpack.core.Preconditions.checkNotNull;
 
 /**
-* Created on 5/30/14.
-*/
+ * Immutable BigIntegerValue implementation
+ */
 public class BigIntegerValueImpl extends AbstractValue implements IntegerValue {
 
     private final BigInteger value;
@@ -74,7 +74,7 @@ public double toDouble() {
 
     @Override
     public byte asByte() throws MessageIntegerOverflowException {
-        if (!isValidByte()) {
+        if(!isValidByte()) {
             throw new MessageIntegerOverflowException(value);
         }
         return value.byteValue();
@@ -82,7 +82,7 @@ public byte asByte() throws MessageIntegerOverflowException {
 
     @Override
     public short asShort() throws MessageIntegerOverflowException {
-        if (!isValidShort()) {
+        if(!isValidShort()) {
             throw new MessageIntegerOverflowException(value);
         }
         return value.shortValue();
@@ -90,7 +90,7 @@ public short asShort() throws MessageIntegerOverflowException {
 
     @Override
     public int asInt() throws MessageIntegerOverflowException {
-        if (!isValidInt()) {
+        if(!isValidInt()) {
             throw new MessageIntegerOverflowException(value);
         }
         return value.intValue();
@@ -98,7 +98,7 @@ public int asInt() throws MessageIntegerOverflowException {
 
     @Override
     public long asLong() throws MessageIntegerOverflowException {
-        if (!isValidLong()) {
+        if(!isValidLong()) {
             throw new MessageIntegerOverflowException(value);
         }
         return value.longValue();
@@ -142,32 +142,32 @@ public void accept(ValueVisitor visitor) {
         visitor.visitInteger(this);
     }
     @Override
-    public IntegerValue toValue() {
+    public IntegerValue toImmutable() {
         return this;
     }
 
     @Override
     public boolean equals(Object o) {
-        if (o == this) {
+        if(o == this) {
             return true;
         }
-        if (!(o instanceof Value)) {
+        if(!(o instanceof Value)) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isInteger()) {
+        if(!v.isIntegerValue()) {
             return false;
         }
-        IntegerValue iv = v.asInteger();
+        IntegerValue iv = v.asIntegerValue();
         return value.equals(iv.toBigInteger());
     }
 
     @Override
     public int hashCode() {
-        if (INT_MIN.compareTo(value) <= 0 && value.compareTo(INT_MAX) <= 0) {
+        if(INT_MIN.compareTo(value) <= 0 && value.compareTo(INT_MAX) <= 0) {
             return (int) value.longValue();
-        } else if (LONG_MIN.compareTo(value) <= 0
-                && value.compareTo(LONG_MAX) <= 0) {
+        } else if(LONG_MIN.compareTo(value) <= 0
+            && value.compareTo(LONG_MAX) <= 0) {
             long v = value.longValue();
             return (int) (v ^ (v >>> 32));
         }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/BooleanValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/BooleanValueImpl.java
index 0421ef8e0..5ce863358 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/BooleanValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/BooleanValueImpl.java
@@ -35,7 +35,7 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-        return 0;
+        return value ? 1 : 0;
     }
 
     public String toString() {
@@ -46,6 +46,10 @@ public String toString() {
     public boolean toBoolean() {
         return value;
     }
+    @Override
+    public BooleanValue toValue() {
+        return null;
+    }
 
     @Override
     public void writeTo(MessagePacker packer) throws IOException {
@@ -55,10 +59,16 @@ public void writeTo(MessagePacker packer) throws IOException {
     public void accept(ValueVisitor visitor) {
         visitor.visitBoolean(value);
     }
+
     @Override
-    public BooleanValue toValue() {
+    public BooleanValue toImmutable() {
         return this;
     }
 
+    @Override
+    public boolean isImmutable() {
+        return true;
+    }
+
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/CursorImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/CursorImpl.java
index 754ef4700..40d5860c6 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/CursorImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/CursorImpl.java
@@ -4,7 +4,6 @@
 import org.msgpack.value.*;
 import org.msgpack.value.holder.ValueHolder;
 import java.io.IOException;
-import java.util.NoSuchElementException;
 
 /**
  * Cursor implementation
@@ -65,12 +64,6 @@ private final void readNext() {
     public Value next() {
         readNext();
         return valueHolder.get();
-     }
-
-    @Override
-    public ValueRef nextRef() {
-        readNext();
-        return valueHolder.getRef();
     }
 
     private ValueType getValueType() {
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/DoubleValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/DoubleValueImpl.java
index e8382a344..4eca63c07 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/DoubleValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/DoubleValueImpl.java
@@ -3,15 +3,18 @@
 import org.msgpack.core.MessageFloatOverflowException;
 import org.msgpack.core.MessageOverflowException;
 import org.msgpack.core.MessagePacker;
-import org.msgpack.value.*;
+import org.msgpack.value.FloatValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueType;
+import org.msgpack.value.ValueVisitor;
 
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
 /**
-* Created on 5/30/14.
-*/
+ * Immutable DoubleValue implementation
+ */
 public class DoubleValueImpl extends AbstractValue implements FloatValue {
     private final double value;
 
@@ -113,23 +116,24 @@ public BigInteger asBigInteger() throws MessageOverflowException {
 
     @Override
     public boolean equals(Object o) {
-        if (o == this) {
+        if(o == this) {
             return true;
         }
-        if (!(o instanceof Value)) {
+        if(!(o instanceof Value)) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isFloat()) {
+        if(!v.isFloatValue()) {
             return false;
         }
-        return value == v.asFloat().toDouble();
+        return value == v.asFloatValue().toDouble();
     }
 
     @Override
-    public FloatValue toValue() {
-        return ValueFactory.newDouble(value);
+    public FloatValue toImmutable() {
+        return this;
     }
+
     @Override
     public void writeTo(MessagePacker pk) throws IOException {
         pk.packDouble(value);
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ExtendedValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ExtendedValueImpl.java
index 80a28fd78..120830279 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/ExtendedValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/ExtendedValueImpl.java
@@ -38,7 +38,7 @@ public void accept(ValueVisitor visitor) {
     }
 
     @Override
-    public ExtendedValue toValue() {
+    public ExtendedValue toImmutable() {
         return this;
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/FloatValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/FloatValueImpl.java
index 644b81aaa..fe04bf289 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/FloatValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/FloatValueImpl.java
@@ -10,7 +10,7 @@
 import java.math.BigInteger;
 
 /**
-* Created on 5/30/14.
+* Immutable float value implementation
 */
 public class FloatValueImpl extends AbstractValue implements FloatValue {
     private final float value;
@@ -127,10 +127,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isFloat()) {
+        if (!v.isFloatValue()) {
             return false;
         }
-        return (double) value == v.asFloat().toDouble();
+        return value == v.asFloatValue().toFloat();
     }
 
     @Override
@@ -142,7 +142,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitFloat(this);
     }
     @Override
-    public FloatValue toValue() {
+    public FloatValue toImmutable() {
         return this;
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/IntegerValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/IntegerValueImpl.java
index 758fde939..bf98979c9 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/IntegerValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/IntegerValueImpl.java
@@ -9,7 +9,7 @@
 import java.math.BigInteger;
 
 /**
-* Created on 5/30/14.
+* IntegerValue implementation
 */
 public class IntegerValueImpl extends AbstractValue implements IntegerValue {
 
@@ -30,7 +30,7 @@ public ValueType getValueType() {
     }
 
     @Override
-    public IntegerValue asInteger() {
+    public IntegerValue asIntegerValue() {
         return this;
     }
 
@@ -134,7 +134,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitInteger(this);
     }
     @Override
-    public IntegerValue toValue() {
+    public IntegerValue toImmutable() {
         return this;
     }
 
@@ -147,10 +147,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isInteger()) {
+        if (!v.isIntegerValue()) {
             return false;
         }
-        IntegerValue iv = v.asInteger();
+        IntegerValue iv = v.asIntegerValue();
         if (!iv.isValidInt()) {
             return false;
         }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/LongValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/LongValueImpl.java
index 57346fe11..577a01d20 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/LongValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/LongValueImpl.java
@@ -34,7 +34,7 @@ public ValueType getValueType() {
     }
 
     @Override
-    public IntegerValue asInteger() {
+    public IntegerValue asIntegerValue() {
         return this;
     }
 
@@ -140,7 +140,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitInteger(this);
     }
     @Override
-    public IntegerValue toValue() {
+    public IntegerValue toImmutable() {
         return this;
     }
 
@@ -153,10 +153,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isInteger()) {
+        if (!v.isIntegerValue()) {
             return false;
         }
-        IntegerValue iv = v.asInteger();
+        IntegerValue iv = v.asIntegerValue();
         if (!iv.isValidLong()) {
             return false;
         }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/MapCursorImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/MapCursorImpl.java
index fbd74e766..1f20284b6 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/MapCursorImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/MapCursorImpl.java
@@ -1,19 +1,26 @@
 package org.msgpack.value.impl;
 
-import org.msgpack.core.*;
-import org.msgpack.value.*;
+import org.msgpack.core.MessageFormatException;
+import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageUnpacker;
+import org.msgpack.value.KeyValuePair;
+import org.msgpack.value.MapValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+import org.msgpack.value.ValueType;
+import org.msgpack.value.ValueVisitor;
 import org.msgpack.value.holder.ValueHolder;
 
 import java.io.IOException;
-import java.util.Iterator;
+import java.util.HashMap;
 import java.util.Map;
 
 import static org.msgpack.core.MessagePackException.UNSUPPORTED;
 
 /**
- * Created on 6/16/14.
+ * MapCursor implementation
  */
-public class MapCursorImpl extends AbstractValueRef implements MapCursor {
+public class MapCursorImpl extends AbstractValue implements MapValue {
 
     private final ValueHolder valueHolder;
     private MessageUnpacker unpacker;
@@ -45,11 +52,16 @@ public boolean hasNext() {
     }
 
     @Override
-    public ValueRef nextKeyOrValue() {
+    public KeyValuePair next() {
         try {
-            MessageFormat f = unpacker.unpackValue(valueHolder);
+            unpacker.unpackValue(valueHolder);
+            Value key = valueHolder.get().toImmutable();
             cursor++;
-            return valueHolder.getRef();
+
+            unpacker.unpackValue(valueHolder);
+            Value value = valueHolder.get().toImmutable();
+            cursor++;
+            return new KeyValuePair(key, value);
         }
         catch(IOException e) {
             throw new MessageFormatException(e);
@@ -57,9 +69,11 @@ public ValueRef nextKeyOrValue() {
     }
 
     @Override
-    public void skipKeyOrValue() {
+    public void skip() {
         try {
             unpacker.skipValue();
+            unpacker.skipValue();
+            cursor += 2;
         }
         catch(IOException e) {
             throw new MessageFormatException(e);
@@ -69,7 +83,7 @@ public void skipKeyOrValue() {
     @Override
     public void skipAll() {
         while(hasNext()) {
-            skipKeyOrValue();
+            skip();
         }
     }
 
@@ -79,11 +93,6 @@ private void ensureNotTraversed() {
     }
 
 
-    @Override
-    public MapCursor getMapCursor() throws MessageTypeException {
-        return this;
-    }
-
     @Override
     public ValueType getValueType() {
         return ValueType.MAP;
@@ -94,25 +103,57 @@ public void writeTo(MessagePacker packer) throws IOException {
         ensureNotTraversed();
         packer.packMapHeader(mapSize);
         while(hasNext()) {
-            packer.packValue(nextKeyOrValue().toValue());
+            KeyValuePair pair = next();
+            packer.packValue(pair.key);
+            packer.packValue(pair.value);
         }
     }
 
     @Override
     public void accept(ValueVisitor visitor) {
-        visitor.visitMap(this.toValue());
+        visitor.visitMap(this.toImmutable());
     }
 
     @Override
-    public MapValue toValue() {
+    public Value[] toKeyValueArray() {
         ensureNotTraversed();
         Value[] keyValueArray = new Value[mapSize * 2];
         int i = 0;
         while(hasNext()) {
-            keyValueArray[i++] = nextKeyOrValue().toValue();
+            KeyValuePair pair = next();
+            keyValueArray[i++] = pair.key;
+            keyValueArray[i++] = pair.value;
         }
-        return ValueFactory.newMap(keyValueArray);
+        return keyValueArray;
     }
 
+    @Override
+    public KeyValuePair[] toArray() {
+        ensureNotTraversed();
+        KeyValuePair[] result = new KeyValuePair[mapSize];
+        int i = 0;
+        while(hasNext()) {
+            KeyValuePair pair = next();
+            result[i++] = pair;
+        }
+        return result;
+    }
+
+    @Override
+    public Map<Value, Value> toMap() {
+        Map<Value, Value> map = new HashMap<Value, Value>();
+        for(KeyValuePair kv : toArray()) {
+            map.put(kv.key, kv.value);
+        }
+        return map;
+    }
+
+    @Override
+    public MapValue toImmutable() {
+        return ValueFactory.newMap(toKeyValueArray());
+    }
+
+    @Override
+    public boolean isImmutable() { return false; }
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/MapValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/MapValueImpl.java
index 6d6b523ba..1dce38832 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/MapValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/MapValueImpl.java
@@ -5,11 +5,19 @@
 import org.msgpack.value.*;
 
 import java.io.IOException;
-import java.util.*;
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
 
 /**
-* Created on 5/30/14.
-*/
+ * MapValue implementation
+ */
 public class MapValueImpl extends AbstractValue implements MapValue {
     private static MapValueImpl EMPTY = new MapValueImpl(new Value[0]);
 
@@ -30,9 +38,19 @@ public ValueType getValueType() {
     }
 
     @Override
-    public Value[] toKeyValueSeq() {
+    public Value[] toKeyValueArray() {
         return Arrays.copyOf(array, array.length);
     }
+    @Override
+    public KeyValuePair[] toArray() {
+        KeyValuePair[] result = new KeyValuePair[array.length / 2];
+        for(int i = 0; i < result.length; ++i) {
+            result[i] = new KeyValuePair(array[2 * i], array[2 * i + 1]);
+        }
+        return result;
+    }
+
+
     @Override
     public int size() {
         return array.length / 2;
@@ -40,21 +58,23 @@ public int size() {
 
     @Override
     public boolean hasNext() {
-        return cursor < array.length;
+        return cursor < size();
     }
     @Override
-    public ValueRef nextKeyOrValue() {
-        return array[cursor++];
+    public KeyValuePair next() {
+        int pos = cursor;
+        cursor += 2;
+        return new KeyValuePair(array[pos], array[pos + 1]);
     }
 
     @Override
-    public void skipKeyOrValue() {
+    public void skip() {
         cursor++;
     }
     @Override
     public void skipAll() {
         while(hasNext()) {
-            skipKeyOrValue();
+            skip();
         }
     }
 
@@ -75,7 +95,7 @@ public Iterator<Map.Entry<Value, Value>> iterator() {
         }
 
         private class EntrySetIterator implements
-                Iterator<Map.Entry<Value, Value>> {
+            Iterator<Map.Entry<Value, Value>> {
             private int pos = 0;
 
             @Override
@@ -85,7 +105,7 @@ public boolean hasNext() {
 
             @Override
             public Entry<Value, Value> next() {
-                if (pos >= array.length) {
+                if(pos >= array.length) {
                     throw new NoSuchElementException();
                 }
 
@@ -142,7 +162,7 @@ public boolean hasNext() {
 
             @Override
             public Value next() {
-                if (pos >= array.length) {
+                if(pos >= array.length) {
                     throw new NoSuchElementException();
                 }
                 Value v = array[pos];
@@ -174,8 +194,8 @@ public Collection<Value> values() {
 
         @Override
         public Value get(Object key) {
-            for (int i = array.length - 2; i >= 0; i -= 2) {
-                if (array[i].equals(key)) {
+            for(int i = array.length - 2; i >= 0; i -= 2) {
+                if(array[i].equals(key)) {
                     return array[i + 1];
                 }
             }
@@ -191,7 +211,7 @@ public Map<Value, Value> toMap() {
     @Override
     public void writeTo(MessagePacker pk) throws IOException {
         pk.packMapHeader(array.length / 2);
-        for (int i = 0; i < array.length; i++) {
+        for(int i = 0; i < array.length; i++) {
             array[i].writeTo(pk);
         }
     }
@@ -201,39 +221,39 @@ public void accept(ValueVisitor visitor) {
     }
 
     @Override
-    public MapValue toValue() {
+    public MapValue toImmutable() {
         return ValueFactory.newMap(array);
     }
 
     @Override
     public boolean equals(Object o) {
-        if (o == this) {
+        if(o == this) {
             return true;
         }
-        if (!(o instanceof Value)) {
+        if(!(o instanceof Value)) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isMap()) {
+        if(!v.isMapValue()) {
             return false;
         }
 
         Map<Value, Value> mv = v.asMapValue().toMap();
-        if (mv.size() != array.length / 2) {
+        if(mv.size() != array.length / 2) {
             return false;
         }
 
         try {
-            for (int i = 0; i < array.length; i += 2) {
+            for(int i = 0; i < array.length; i += 2) {
                 Value key = array[i];
                 Value value = array[i + 1];
-                if (!value.equals(mv.get(key))) {
+                if(!value.equals(mv.get(key))) {
                     return false;
                 }
             }
-        } catch (ClassCastException ex) {
+        } catch(ClassCastException ex) {
             return false;
-        } catch (NullPointerException ex) {
+        } catch(NullPointerException ex) {
             return false;
         }
 
@@ -243,7 +263,7 @@ public boolean equals(Object o) {
     @Override
     public int hashCode() {
         int h = 0;
-        for (int i = 0; i < array.length; i += 2) {
+        for(int i = 0; i < array.length; i += 2) {
             h += array[i].hashCode() ^ array[i + 1].hashCode();
         }
         return h;
@@ -255,14 +275,14 @@ public String toString() {
     }
 
     private StringBuilder toString(StringBuilder sb) {
-        if (array.length == 0) {
+        if(array.length == 0) {
             return sb.append("{}");
         }
         sb.append("{");
         sb.append(array[0]);
         sb.append(":");
         sb.append(array[1]);
-        for (int i = 2; i < array.length; i += 2) {
+        for(int i = 2; i < array.length; i += 2) {
             sb.append(",");
             sb.append(array[i].toString());
             sb.append(":");
@@ -273,5 +293,4 @@ private StringBuilder toString(StringBuilder sb) {
     }
 
 
-
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/NilValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/NilValueImpl.java
index 3fea78364..d82906608 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/NilValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/NilValueImpl.java
@@ -9,7 +9,7 @@
 import java.io.IOException;
 
 /**
-* Created on 5/30/14.
+* Immutable NilValue implementation
 */
 public class NilValueImpl extends AbstractValue implements NilValue {
 
@@ -32,7 +32,7 @@ public boolean equals(Object o) {
         if (!(o instanceof Value)) {
             return false;
         }
-        return ((Value) o).isNil();
+        return ((Value) o).isNilValue();
     }
 
     @Override
@@ -54,7 +54,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitNil();
     }
     @Override
-    public NilValue toValue() {
+    public NilValue toImmutable() {
         return instance;
     }
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/RawStringValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/RawStringValueImpl.java
index a4b0e43bd..ba0f232b2 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/RawStringValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/RawStringValueImpl.java
@@ -8,7 +8,7 @@
 import java.nio.ByteBuffer;
 
 /**
-* Created on 5/30/14.
+* Immutable raw string value implementation
 */
 public class RawStringValueImpl extends RawValueImpl implements StringValue {
 
@@ -38,7 +38,7 @@ public void writeTo(MessagePacker pk) throws IOException {
     }
 
     @Override
-    public StringValue toValue() {
+    public StringValue toImmutable() {
         return this;
     }
 
@@ -51,10 +51,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isString()) {
+        if (!v.isStringValue()) {
             return false;
         }
-        StringValue sv = v.asString();
+        StringValue sv = v.asStringValue();
         return sv.toByteBuffer().equals(byteBuffer);
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/RawValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/RawValueImpl.java
index b69677503..550243e78 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/RawValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/RawValueImpl.java
@@ -1,5 +1,6 @@
 package org.msgpack.value.impl;
 
+import org.msgpack.core.MessagePack;
 import org.msgpack.core.MessagePacker;
 import org.msgpack.core.MessageStringCodingException;
 import org.msgpack.core.buffer.MessageBuffer;
@@ -12,7 +13,7 @@
 import java.nio.charset.*;
 
 /**
-* Created on 5/30/14.
+* Immutable RawValue implementation bas
 */
 public abstract class RawValueImpl extends AbstractValue implements RawValue {
 
@@ -32,7 +33,7 @@ public byte[] toByteArray() {
     }
 
     @Override
-    public RawValue toValue() {
+    public RawValue toImmutable() {
         return this;
     }
 
@@ -63,7 +64,7 @@ private synchronized void decodeString() {
             return;
         }
         try {
-            CharsetDecoder reportDecoder = Charset.forName("UTF-8").newDecoder()
+            CharsetDecoder reportDecoder = MessagePack.UTF8.newDecoder()
                     .onMalformedInput(CodingErrorAction.REPLACE)
                     .onUnmappableCharacter(CodingErrorAction.REPLACE);
             decodedStringCache = reportDecoder.decode(byteBuffer.asReadOnlyBuffer()).toString();
@@ -72,7 +73,7 @@ private synchronized void decodeString() {
         } catch (CharacterCodingException ex) {
             codingException = new MessageStringCodingException(ex);
             try {
-                CharsetDecoder replaceDecoder = Charset.forName("UTF-8").newDecoder()
+                CharsetDecoder replaceDecoder = MessagePack.UTF8.newDecoder()
                         .onMalformedInput(CodingErrorAction.REPLACE)
                         .onUnmappableCharacter(CodingErrorAction.REPLACE);
                 decodedStringCache = replaceDecoder.decode(byteBuffer.asReadOnlyBuffer()).toString();
@@ -93,10 +94,10 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isBinary()) {
+        if (!v.isBinaryValue()) {
             return false;
         }
-        BinaryValue bv = v.asBinary();
+        BinaryValue bv = v.asBinaryValue();
         return bv.toByteBuffer().equals(byteBuffer);
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/StringValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/StringValueImpl.java
index 0b9888648..1289c007f 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/StringValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/StringValueImpl.java
@@ -11,7 +11,7 @@
 import java.nio.ByteBuffer;
 
 /**
-* Created on 5/30/14.
+* Immutable StringValue implementation
 */
 public class StringValueImpl extends AbstractValue implements StringValue {
 
@@ -55,7 +55,7 @@ public void accept(ValueVisitor visitor) {
         visitor.visitString(this);
     }
     @Override
-    public StringValue toValue() {
+    public StringValue toImmutable() {
         return ValueFactory.newString(value);
     }
 
@@ -68,11 +68,11 @@ public boolean equals(Object o) {
             return false;
         }
         Value v = (Value) o;
-        if (!v.isString()) {
+        if (!v.isStringValue()) {
             return false;
         }
         try {
-            return v.asString().toString().equals(value);
+            return v.asStringValue().toString().equals(value);
         } catch (MessageStringCodingException ex) {
             return false;
         }
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
index 116160dd1..9938925cd 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
@@ -448,15 +448,15 @@ class MessagePackTest extends MessagePackSpec  {
         unpacker.unpackValue(holder)
         val v = holder.get()
 
-        v.asArrayValue().toValueArray.map { m =>
+        v.asArrayValue().toArray.map { m =>
           val mv = m.asMapValue()
-          val kvs = mv.toKeyValueSeq
+          val kvs = mv.toKeyValueArray
 
           kvs.grouped(2).map({ kvp: Array[Value] =>
             val k = kvp(0)
             val v = kvp(1)
 
-            (k.asString().toString, v.asString().toString)
+            (k.asStringValue().toString, v.asStringValue().toString)
           }).toMap
         }.toList
       })
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/CursorTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/CursorTest.scala
index ee46ff7bd..ccb3d3e4e 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/CursorTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/CursorTest.scala
@@ -60,7 +60,7 @@ class CursorTest extends MessagePackSpec {
 
       val cursor = msgpack.newUnpacker(sampleData).getCursor
       // Traverse as references
-      val arrCursor = cursor.nextRef().getArrayCursor
+      val arrCursor = cursor.next().asArrayValue()
       arrCursor.size() shouldBe 3
 
       import scala.collection.JavaConversions._
@@ -75,34 +75,34 @@ class CursorTest extends MessagePackSpec {
       }
 
       val cursor = msgpack.newUnpacker(packedData).getCursor
-      val mapCursor = cursor.nextRef().getMapCursor
+      val mapCursor = cursor.next().asMapValue()
       mapCursor.size() shouldBe 1
 
-      val mapValue = mapCursor.toValue
-      val data = mapValue.toKeyValueSeq
+      val mapValue = mapCursor.toImmutable
+      val data = mapValue.toKeyValueArray
 
       data should have length 2
 
-      data(0).asString().toString shouldBe "f"
-      data(1).asString().toString shouldBe "x"
+      data(0).asStringValue().toString shouldBe "f"
+      data(1).asStringValue().toString shouldBe "x"
     }
 
-    "traverse ValueRef faster than traversing Value" taggedAs("ref") in {
+    "traverse faster than extracting immutable values" taggedAs("ref") in {
       val N = 10000
       val data = binSeq(N)
 
       time("traversal", repeat=100) {
-        block("value") {
+        block("immutable") {
           val cursor = msgpack.newUnpacker(data).getCursor
           while(cursor.hasNext) {
-            cursor.next()
+            cursor.next().toImmutable
           }
           cursor.close()
         }
-        block("value-ref") {
+        block("cursor") {
           val cursor = msgpack.newUnpacker(data).getCursor
           while(cursor.hasNext) {
-            cursor.nextRef()
+            cursor.next()
           }
           cursor.close()
         }
@@ -121,7 +121,7 @@ class CursorTest extends MessagePackSpec {
           while(unpacker.hasNext) {
             val vt = unpacker.getNextFormat.getValueType
             if(vt.isIntegerType) {
-              unpacker.unpackInteger(intHolder);
+              unpacker.unpackInteger(intHolder)
               count += 1
             }
             else {
@@ -135,8 +135,8 @@ class CursorTest extends MessagePackSpec {
           var count = 0
           val cursor = msgpack.newUnpacker(data).getCursor
           while(cursor.hasNext) {
-            val ref = cursor.nextRef()
-            val v = ref.asInteger().toInt
+            val ref = cursor.next()
+            val v = ref.asIntegerValue().toInt
             count += 1
           }
           cursor.close()
@@ -179,19 +179,24 @@ class CursorTest extends MessagePackSpec {
       val unpacker = msgpack.newUnpacker(m)
       val vh = new ValueHolder
       unpacker.unpackValue(vh)
-      val mapValue = vh.get().asMapValue()
+      val mapValue = vh.get().asMapValue().toImmutable
+      info(mapValue)
 
       val map = mapValue.toMap
       map.size shouldBe 3
 
-      val arr = map.get(ValueFactory.newString("A")).asArrayValue()
+      //import scala.collection.JavaConversions._
+      //info(map.map(p => s"${p._1}->${p._2}").mkString(", "))
+
+      val k = map.get(ValueFactory.newString("A"))
+      val arr = k.asArrayValue()
       arr.size shouldBe 2
 
       val cmap = map.get(ValueFactory.newString("C")).asMapValue()
       cmap.size shouldBe 3
       cmap.toMap.get(ValueFactory.newString("c")).asMapValue().size() shouldBe 1
 
-      info(mapValue)
+
     }
 
 
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
index cb79a575e..59b7592e3 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
@@ -22,17 +22,17 @@ class ValueFactoryTest extends MessagePackSpec {
               isRaw : Boolean = false,
               isNumber : Boolean = false
                ) {
-    v.isNil shouldBe isNil
-    v.isBoolean shouldBe isBoolean
-    v.isInteger shouldBe isInteger
-    v.isFloat shouldBe isFloat
-    v.isString shouldBe isString
-    v.isBinary shouldBe isBinary
-    v.isArray shouldBe isArray
-    v.isMap shouldBe isMap
-    v.isExtended shouldBe isExtended
-    v.isRaw shouldBe isRaw
-    v.isNumber shouldBe isNumber
+    v.isNilValue shouldBe isNil
+    v.isBooleanValue shouldBe isBoolean
+    v.isIntegerValue shouldBe isInteger
+    v.isFloatValue shouldBe isFloat
+    v.isStringValue shouldBe isString
+    v.isBinaryValue shouldBe isBinary
+    v.isArrayValue shouldBe isArray
+    v.isMapValue shouldBe isMap
+    v.isExtendedValue shouldBe isExtended
+    v.isRawValue shouldBe isRaw
+    v.isNumberValue shouldBe isNumber
   }
 
   "ValueFactory" should {
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
index 07e5c724f..52a5792fd 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
@@ -136,7 +136,7 @@ public JsonToken nextToken() throws IOException, JsonParseException {
             case STRING:
                 messageUnpacker.unpackValue(valueHolder);
                 if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(valueHolder.getRef().asRaw().toString());
+                    parsingContext.setCurrentName(valueHolder.get().asRawValue().toString());
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
@@ -185,7 +185,7 @@ protected void _handleEOF() throws JsonParseException {}
     @Override
     public String getText() throws IOException, JsonParseException {
         // This method can be called for new BigInteger(text)
-        return valueHolder.getRef().toString();
+        return valueHolder.get().toString();
     }
 
     @Override
@@ -210,12 +210,12 @@ public int getTextOffset() throws IOException, JsonParseException {
 
     @Override
     public byte[] getBinaryValue(Base64Variant b64variant) throws IOException, JsonParseException {
-        return valueHolder.getRef().asBinary().toByteArray();
+        return valueHolder.get().asBinaryValue().toByteArray();
     }
 
     @Override
     public Number getNumberValue() throws IOException, JsonParseException {
-        NumberValue numberValue = valueHolder.getRef().asNumber();
+        NumberValue numberValue = valueHolder.get().asNumberValue();
         if (numberValue.isValidInt()) {
             return numberValue.toInt();
         }
@@ -229,27 +229,27 @@ else if (numberValue.isValidLong()) {
 
     @Override
     public int getIntValue() throws IOException, JsonParseException {
-        return valueHolder.getRef().asNumber().toInt();
+        return valueHolder.get().asNumberValue().toInt();
     }
 
     @Override
     public long getLongValue() throws IOException, JsonParseException {
-        return valueHolder.getRef().asNumber().toLong();
+        return valueHolder.get().asNumberValue().toLong();
     }
 
     @Override
     public BigInteger getBigIntegerValue() throws IOException, JsonParseException {
-        return valueHolder.getRef().asNumber().toBigInteger();
+        return valueHolder.get().asNumberValue().toBigInteger();
     }
 
     @Override
     public float getFloatValue() throws IOException, JsonParseException {
-        return valueHolder.getRef().asFloat().toFloat();
+        return valueHolder.get().asFloatValue().toFloat();
     }
 
     @Override
     public double getDoubleValue() throws IOException, JsonParseException {
-        return valueHolder.getRef().asFloat().toDouble();
+        return valueHolder.get().asFloatValue().toDouble();
     }
 
     @Override
@@ -259,12 +259,12 @@ public BigDecimal getDecimalValue() throws IOException {
 
     @Override
     public Object getEmbeddedObject() throws IOException, JsonParseException {
-        return valueHolder.getRef().asBinary().toByteArray();
+        return valueHolder.get().asBinaryValue().toByteArray();
     }
 
     @Override
     public NumberType getNumberType() throws IOException, JsonParseException {
-        NumberValue numberValue = valueHolder.getRef().asNumber();
+        NumberValue numberValue = valueHolder.get().asNumberValue();
         if (numberValue.isValidInt()) {
             return NumberType.INT;
         }
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
index 52a2203bc..8e250650d 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
@@ -26,8 +26,8 @@
 import java.util.List;
 
 public class MessagePackDataformatHugeDataBenchmarkTest extends MessagePackDataformatTestBase {
-    private static final int ELM_NUM = 1500000;
-    private static final int SAMPLING_COUNT = 4;
+    private static final int ELM_NUM = 500000;
+    private static final int SAMPLING_COUNT = 10;
     private final ObjectMapper origObjectMapper = new ObjectMapper();
     private final ObjectMapper msgpackObjectMapper = new ObjectMapper(new MessagePackFactory());
     private static final List<Object> value;
diff --git a/version.sbt b/version.sbt
index ebe5ed032..e6f8a298d 100644
--- a/version.sbt
+++ b/version.sbt
@@ -1 +1 @@
-version in ThisBuild := "0.7.0-p2"
+version in ThisBuild := "0.7.0-M6-SNAPSHOT"