diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java b/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java
index e8ca72191e..7fb74da4cf 100644
--- a/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java
+++ b/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java
@@ -716,7 +716,7 @@ protected void _addImplicitFactoryCreators(DeserializationContext ctxt,
                 }
                 continue;
             }
-            AnnotatedParameter nonAnnotatedParam = null;            
+            AnnotatedParameter nonAnnotatedParam = null;
             SettableBeanProperty[] properties = new SettableBeanProperty[argCount];
             int implicitNameCount = 0;
             int explicitNameCount = 0;
@@ -1474,6 +1474,18 @@ public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationConte
         return deser;
     }
 
+    @Override
+    public JsonDeserializer<?> createTupleDeserializer(DeserializationContext ctxt,
+            TupleType type, BeanDescription beanDesc)
+        throws JsonMappingException
+    {
+        CollectionType ct = ctxt.getTypeFactory().constructCollectionType(Collection.class,
+                TypeFactory.unknownType());
+        CollectionDeserializer deser = (CollectionDeserializer) createCollectionDeserializer(ctxt,
+                ct, beanDesc);
+        return new TupleDeserializer(deser, type);
+    }
+
     /*
     /**********************************************************
     /* DeserializerFactory impl: Map(-like) deserializers
@@ -2010,7 +2022,7 @@ public TypeDeserializer findPropertyTypeDeserializer(DeserializationConfig confi
         throws JsonMappingException
     {
         AnnotationIntrospector ai = config.getAnnotationIntrospector();
-        TypeResolverBuilder<?> b = ai.findPropertyTypeResolver(config, annotated, baseType);        
+        TypeResolverBuilder<?> b = ai.findPropertyTypeResolver(config, annotated, baseType);
         // Defaulting: if no annotations on member, check value class
         if (b == null) {
             return findTypeDeserializer(config, baseType);
@@ -2037,13 +2049,13 @@ public TypeDeserializer findPropertyTypeDeserializer(DeserializationConfig confi
      * 
      * @param containerType Type of property; must be a container type
      * @param propertyEntity Field or method that contains container property
-     */    
+     */
     public TypeDeserializer findPropertyContentTypeDeserializer(DeserializationConfig config,
             JavaType containerType, AnnotatedMember propertyEntity)
         throws JsonMappingException
     {
         AnnotationIntrospector ai = config.getAnnotationIntrospector();
-        TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, propertyEntity, containerType);        
+        TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, propertyEntity, containerType);
         JavaType contentType = containerType.getContentType();
         // Defaulting: if no annotations on member, check class
         if (b == null) {
@@ -2086,13 +2098,17 @@ public JsonDeserializer<?> findDefaultDeserializer(DeserializationContext ctxt,
             return StringDeserializer.instance;
         }
         if (rawType == CLASS_ITERABLE) {
-            // [databind#199]: Can and should 'upgrade' to a Collection type:
-            TypeFactory tf = ctxt.getTypeFactory();
-            JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE);
-            JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0];
-            CollectionType ct = tf.constructCollectionType(Collection.class, elemType);
-            // Should we re-introspect beanDesc? For now let's not...
-            return createCollectionDeserializer(ctxt, ct, beanDesc);
+            if (type instanceof TupleType) {
+                return createTupleDeserializer(ctxt, (TupleType) type, beanDesc);
+            } else {
+                // [databind#199]: Can and should 'upgrade' to a Collection type:
+                TypeFactory tf = ctxt.getTypeFactory();
+                JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE);
+                // Should we re-introspect beanDesc? For now let's not...
+                JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0];
+                CollectionType ct = tf.constructCollectionType(Collection.class, elemType);
+                return createCollectionDeserializer(ctxt, ct, beanDesc);
+            }
         }
         if (rawType == CLASS_MAP_ENTRY) {
             // 28-Apr-2015, tatu: TypeFactory does it all for us already so
@@ -2375,7 +2391,7 @@ protected JavaType resolveMemberAndTypeAnnotations(DeserializationContext ctxt,
                 type = type.withContentValueHandler(cd);
             }
             TypeDeserializer contentTypeDeser = findPropertyContentTypeDeserializer(
-                    ctxt.getConfig(), type, (AnnotatedMember) member);            	
+                    ctxt.getConfig(), type, (AnnotatedMember) member);
             if (contentTypeDeser != null) {
                 type = type.withContentTypeHandler(contentTypeDeser);
             }
@@ -2418,7 +2434,7 @@ protected boolean _hasCreatorAnnotation(DeserializationContext ctxt,
         AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
         if (intr != null) {
             JsonCreator.Mode mode = intr.findCreatorAnnotation(ctxt.getConfig(), ann);
-            return (mode != null) && (mode != JsonCreator.Mode.DISABLED); 
+            return (mode != null) && (mode != JsonCreator.Mode.DISABLED);
         }
         return false;
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/DeserializerFactory.java b/src/main/java/com/fasterxml/jackson/databind/deser/DeserializerFactory.java
index 4451fccffe..6fb8503a67 100644
--- a/src/main/java/com/fasterxml/jackson/databind/deser/DeserializerFactory.java
+++ b/src/main/java/com/fasterxml/jackson/databind/deser/DeserializerFactory.java
@@ -10,7 +10,7 @@
  * {@link JsonDeserializer} instances (which are then cached by
  * context and/or dedicated cache).
  *<p>
- * Since there are multiple broad categories of deserializers, there are 
+ * Since there are multiple broad categories of deserializers, there are
  * multiple factory methods:
  *<ul>
  * <li>For JSON "Array" type, we need 2 methods: one to deal with expected
@@ -165,6 +165,10 @@ public abstract JsonDeserializer<?> createCollectionLikeDeserializer(Deserializa
             CollectionLikeType type, BeanDescription beanDesc)
         throws JsonMappingException;
 
+    public abstract JsonDeserializer<?> createTupleDeserializer(DeserializationContext ctxt,
+            TupleType type, BeanDescription beanDesc)
+        throws JsonMappingException;
+
     public abstract JsonDeserializer<?> createMapDeserializer(DeserializationContext ctxt,
             MapType type, BeanDescription beanDesc)
         throws JsonMappingException;
@@ -208,7 +212,7 @@ public abstract TypeDeserializer findTypeDeserializer(DeserializationConfig conf
      * given type as opposed to auto-generated "Bean" deserializer. Factory itself will check
      * for known JDK-provided types, but registered {@link com.fasterxml.jackson.databind.Module}s
      * are also called to see if they might provide explicit deserializer.
-     *<p> 
+     *<p>
      * Main use for this method is with Safe Default Typing (and generally Safe Polymorphic
      * Deserialization), during which it is good to be able to check that given raw type
      * is explicitly supported and as such "known type" (as opposed to potentially
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/std/TupleDeserializer.java b/src/main/java/com/fasterxml/jackson/databind/deser/std/TupleDeserializer.java
new file mode 100644
index 0000000000..ec77664d41
--- /dev/null
+++ b/src/main/java/com/fasterxml/jackson/databind/deser/std/TupleDeserializer.java
@@ -0,0 +1,119 @@
+package com.fasterxml.jackson.databind.deser.std;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.BeanProperty;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
+import com.fasterxml.jackson.databind.deser.NullValueProvider;
+import com.fasterxml.jackson.databind.deser.ValueInstantiator;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+import com.fasterxml.jackson.databind.type.TupleType;
+import com.fasterxml.jackson.databind.util.ClassUtil;
+
+/**
+ * TupleDeserializer
+ */
+@JacksonStdImpl
+public class TupleDeserializer extends CollectionDeserializer {
+    private static final long serialVersionUID = 1L;
+
+    private TupleType tupleType;
+
+    private List<JsonDeserializer<Object>> valueDeserList;
+
+    private List<NullValueProvider> nullerList;
+
+    public TupleDeserializer(CollectionDeserializer deser, TupleType tupleType)
+    {
+        // disable unwrapSingle.
+        super(deser._valueType,
+                deser._valueDeserializer, deser._valueTypeDeserializer,
+                deser._valueInstantiator, deser._delegateDeserializer,
+                deser._nullProvider, false);
+        this.tupleType = tupleType;
+        this.valueDeserList = new ArrayList<>();
+        this.nullerList = new ArrayList<>();
+    }
+
+    protected TupleDeserializer (JavaType containerType,
+            JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser,
+            ValueInstantiator valueInstantiator,
+            JsonDeserializer<Object> delegateDeser,
+            NullValueProvider nuller,
+            TupleType tupleType,
+            List<JsonDeserializer<Object>> valueDeserList, List<NullValueProvider> nullerList)
+    {
+        // disable unwrapSingle.
+        super(containerType, valueDeser, valueTypeDeser, valueInstantiator, delegateDeser,
+                nuller, false);
+        this.tupleType = tupleType;
+        this.valueDeserList = valueDeserList;
+        this.nullerList = nullerList;
+    }
+
+    @Override
+    protected Collection<Object> _deserializeFromArray(JsonParser p, DeserializationContext ctxt,
+            Collection<Object> result)
+        throws IOException
+    {
+        p.setCurrentValue(result);
+
+        JsonToken t;
+        int idx = 0;
+        while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
+            try {
+                Object value;
+                if (t == JsonToken.VALUE_NULL) {
+                    value = nullerList.get(idx++).getNullValue(ctxt);
+                } else {
+                    value = valueDeserList.get(idx++).deserialize(p, ctxt);
+                }
+                result.add(value);
+            } catch (Exception e) {
+                boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
+                if (!wrap) {
+                    ClassUtil.throwIfRTE(e);
+                }
+                throw JsonMappingException.wrapWithPath(e, result, result.size());
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public CollectionDeserializer createContextual(DeserializationContext ctxt,
+            BeanProperty property) throws JsonMappingException
+    {
+        for (JavaType type : tupleType.getBindings().getTypeParameters()) {
+            JsonDeserializer<Object> valueDeser = ctxt.findContextualValueDeserializer(type, null);
+            NullValueProvider nuller = findContentNullProvider(ctxt, null, valueDeser);
+            this.valueDeserList.add(valueDeser);
+            this.nullerList.add(nuller);
+        }
+        return super.createContextual(ctxt, property);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected TupleDeserializer withResolved(JsonDeserializer<?> dd,
+            JsonDeserializer<?> vd, TypeDeserializer vtd,
+            NullValueProvider nuller, Boolean unwrapSingle)
+    {
+        return new TupleDeserializer(_containerType,
+                (JsonDeserializer<Object>) vd, vtd,
+                _valueInstantiator, (JsonDeserializer<Object>) dd,
+                nuller,
+                this.tupleType,
+                this.valueDeserList, this.nullerList);
+    }
+}
diff --git a/src/main/java/com/fasterxml/jackson/databind/type/TupleType.java b/src/main/java/com/fasterxml/jackson/databind/type/TupleType.java
new file mode 100644
index 0000000000..8ad5a5f7e3
--- /dev/null
+++ b/src/main/java/com/fasterxml/jackson/databind/type/TupleType.java
@@ -0,0 +1,21 @@
+package com.fasterxml.jackson.databind.type;
+
+/**
+ * Tuple types are defined as list with fixed element types format.
+ */
+public class TupleType extends SimpleType {
+    private static final long serialVersionUID = 1L;
+
+    protected TupleType(SimpleType base)
+    {
+        super(base);
+    }
+
+    @Override
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder(40);
+        sb.append("[tuple type, class ").append(buildCanonicalName()).append(']');
+        return sb.toString();
+    }
+}
diff --git a/src/main/java/com/fasterxml/jackson/databind/type/TypeBindings.java b/src/main/java/com/fasterxml/jackson/databind/type/TypeBindings.java
index b9422b2bc7..01286fc552 100644
--- a/src/main/java/com/fasterxml/jackson/databind/type/TypeBindings.java
+++ b/src/main/java/com/fasterxml/jackson/databind/type/TypeBindings.java
@@ -64,6 +64,18 @@ private TypeBindings(String[] names, JavaType[] types, String[] uvars)
         _hashCode = h;
     }
 
+    private TypeBindings(String[] names, JavaType[] elementTypes)
+    {
+        _names = (names == null) ? NO_STRINGS : names;
+        _types = (elementTypes == null) ? NO_TYPES : elementTypes;
+        int h = 1;
+        for (int i = 0, len = _types.length; i < len; ++i) {
+            h += _types[i].hashCode();
+        }
+        _unboundVariables = null;
+        _hashCode = h;
+    }
+
     public static TypeBindings emptyBindings() {
         return EMPTY;
     }
@@ -117,6 +129,15 @@ public static TypeBindings create(Class<?> erasedType, JavaType[] types)
         return new TypeBindings(names, types, null);
     }
 
+    public static TypeBindings createTuple(JavaType[] elementTypes)
+    {
+        if (elementTypes == null) {
+            elementTypes = NO_TYPES;
+        }
+        return new TypeBindings(new String[] { TypeParamStash.VARS_ITERABLE[0].getName() },
+                elementTypes);
+    }
+
     public static TypeBindings create(Class<?> erasedType, JavaType typeArg1)
     {
         // 30-Oct-2015, tatu: Minor optimization for relatively common cases
@@ -260,7 +281,7 @@ public boolean isEmpty() {
     /**
      * Returns number of bindings contained
      */
-    public int size() { 
+    public int size() {
         return _types.length;
     }
 
@@ -420,7 +441,7 @@ public static TypeVariable<?>[] paramsFor1(Class<?> erasedType)
                 return VARS_ITERABLE;
             }
             return erasedType.getTypeParameters();
-        }    
+        }
 
         public static TypeVariable<?>[] paramsFor2(Class<?> erasedType)
         {
@@ -434,7 +455,7 @@ public static TypeVariable<?>[] paramsFor2(Class<?> erasedType)
                 return VARS_LINKED_HASH_MAP;
             }
             return erasedType.getTypeParameters();
-        }    
+        }
     }
 
     /**
diff --git a/src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java b/src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java
index b3168c8b43..be7cb53ae2 100644
--- a/src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java
+++ b/src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java
@@ -20,7 +20,7 @@
  * as well as many objects it constructs (like
 * {@link com.fasterxml.jackson.databind.DeserializationConfig} and
  * {@link com.fasterxml.jackson.databind.SerializationConfig})),
- * but usually those objects also 
+ * but usually those objects also
  * expose convenience methods (<code>constructType</code>).
  * So, you can do for example:
  *<pre>
@@ -227,7 +227,7 @@ protected TypeFactory(LookupCache<Object,JavaType> typeCache, TypeParser p,
      * {@link TypeModifier} added as the first modifier to call (in case there
      * are multiple registered).
      */
-    public TypeFactory withModifier(TypeModifier mod) 
+    public TypeFactory withModifier(TypeModifier mod)
     {
         LookupCache<Object,JavaType> typeCache = _typeCache;
         TypeModifier[] mods;
@@ -699,7 +699,7 @@ public JavaType[] findTypeParameters(JavaType type, Class<?> expType)
     /**
      * @deprecated Since 2.7 resolve raw type first, then find type parameters
      */
-    @Deprecated // since 2.7    
+    @Deprecated // since 2.7
     public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings) {
         return findTypeParameters(constructType(clz, bindings), expType);
     }
@@ -707,7 +707,7 @@ public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBinding
     /**
      * @deprecated Since 2.7 resolve raw type first, then find type parameters
      */
-    @Deprecated // since 2.7    
+    @Deprecated // since 2.7
     public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType) {
         return findTypeParameters(constructType(clz), expType);
     }
@@ -790,7 +790,7 @@ public JavaType constructType(TypeReference<?> typeRef)
      *
      * @return Fully resolve type
      *
-     * @since 2.12 as replacement for deprecated {@link #constructType(Type, TypeBindings)} 
+     * @since 2.12 as replacement for deprecated {@link #constructType(Type, TypeBindings)}
      */
     public JavaType resolveMemberType(Type type, TypeBindings contextBindings) {
         return _fromAny(null, type, contextBindings);
@@ -1033,6 +1033,27 @@ public JavaType constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)
         return _fromClass(null, rawType, TypeBindings.create(rawType, parameterTypes));
     }
 
+    /**
+     * Method for constructing a type instance with fixed element types.
+     * <p>
+     * for example:
+     * first element of "[1,2,3,null]" is Integer, second element is BigDecimal,
+     * third element is Long, fourth element is String.
+     */
+    public JavaType constructTupleType(JavaType[] elementTypes) {
+        return new TupleType((SimpleType) _fromClass(null, Iterable.class,
+                TypeBindings.createTuple(elementTypes)));
+    }
+
+    public JavaType constructTupleType(Class<?>[] elementClazzs) {
+        JavaType[] elementTypes = new JavaType[elementClazzs.length];
+        int idx = 0;
+        for (Class<?> clazz : elementClazzs) {
+            elementTypes[idx++] = constructType(clazz);
+        }
+        return constructTupleType(elementTypes);
+    }
+
     /**
      * Method for constructing a type instance with specified parameterization.
      *
@@ -1045,7 +1066,7 @@ public JavaType constructSimpleType(Class<?> rawType, Class<?> parameterTarget,
             JavaType[] parameterTypes)
     {
         return constructSimpleType(rawType, parameterTypes);
-    } 
+    }
 
     /**
      * Method for constructing a {@link ReferenceType} instance with given type parameter
@@ -1066,7 +1087,7 @@ public JavaType constructReferenceType(Class<?> rawType, JavaType referredType)
     /**
      * Method that use by core Databind functionality, and that should NOT be called
      * by application code outside databind package.
-     *<p> 
+     *<p>
      * Unchecked here not only means that no checks are made as to whether given class
      * might be non-simple type (like {@link CollectionType}) but also that most of supertype
      * information is not gathered. This means that unless called on primitive types or
@@ -1506,7 +1527,7 @@ else if (superClass != null) {
             }
             // if not, perhaps we are now resolving a well-known class or interface?
             if (result == null) {
-                result = _fromWellKnownClass(context, rawType, bindings, superClass, superInterfaces); 
+                result = _fromWellKnownClass(context, rawType, bindings, superClass, superInterfaces);
                 if (result == null) {
                     result = _fromWellKnownInterface(context, rawType, bindings, superClass, superInterfaces);
                     if (result == null) {
@@ -1615,10 +1636,10 @@ protected JavaType _fromParamType(ClassStack context, ParameterizedType ptype,
 
         // First: what is the actual base type? One odd thing is that 'getRawType'
         // returns Type, not Class<?> as one might expect. But let's assume it is
-        // always of type Class: if not, need to add more code to resolve it to Class.        
+        // always of type Class: if not, need to add more code to resolve it to Class.
         Type[] args = ptype.getActualTypeArguments();
         int paramCount = (args == null) ? 0 : args.length;
-        TypeBindings newBindings;        
+        TypeBindings newBindings;
 
         if (paramCount == 0) {
             newBindings = EMPTY_BINDINGS;
@@ -1661,7 +1682,7 @@ protected JavaType _fromVariable(ClassStack context, TypeVariable<?> var, TypeBi
         // 15-Jan-2019, tatu: As weird as this looks, apparently on some platforms (Arm CPU, mobile
         //    devices), unsynchronized internal access can lead to issues, see:
         //
-        //  https://vmlens.com/articles/java-lang-reflect-typevariable-getbounds-is-not-thread-safe/  
+        //  https://vmlens.com/articles/java-lang-reflect-typevariable-getbounds-is-not-thread-safe/
         //
         //    No good way to reproduce but since this should not be on critical path, let's add
         //    syncing as it seems potentially necessary.
diff --git a/src/test/java/com/fasterxml/jackson/databind/ObjectReaderTest.java b/src/test/java/com/fasterxml/jackson/databind/ObjectReaderTest.java
index 706d5189e4..ea4a071554 100644
--- a/src/test/java/com/fasterxml/jackson/databind/ObjectReaderTest.java
+++ b/src/test/java/com/fasterxml/jackson/databind/ObjectReaderTest.java
@@ -2,17 +2,20 @@
 
 import java.io.IOException;
 import java.io.StringWriter;
+import java.math.BigDecimal;
 import java.util.*;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.core.*;
 import com.fasterxml.jackson.core.exc.StreamReadException;
 import com.fasterxml.jackson.core.json.JsonReadFeature;
-
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.cfg.ContextAttributes;
+import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
 import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 import com.fasterxml.jackson.databind.exc.InvalidDefinitionException;
 import com.fasterxml.jackson.databind.exc.MismatchedInputException;
 import com.fasterxml.jackson.databind.json.JsonMapper;
@@ -414,7 +417,7 @@ public void testPointerWithArrays() throws Exception
     public static class Pojo1637 {
         public Set<String> set1;
         public Set<String> set2;
-    }    
+    }
 
     // [databind#2636]
     public void testCanPassResultToOverloadedMethod() throws Exception {
@@ -532,4 +535,197 @@ private A(@JsonProperty("knownField") String knownField) {
             this.knownField = knownField;
         }
     }
+
+    @SuppressWarnings("unchecked")
+    public void testReaderForTupleType() throws IOException {
+        JavaType[] elementTypes = new JavaType[] {
+                MAPPER.getTypeFactory().constructType(Integer.class),
+                MAPPER.getTypeFactory().constructType(BigDecimal.class),
+                MAPPER.getTypeFactory().constructType(Long.class),
+                MAPPER.getTypeFactory().constructType(String.class),
+                MAPPER.getTypeFactory().constructParametricType(Generic.class, BigDecimal.class),
+                MAPPER.getTypeFactory().constructCollectionType(List.class, Shape.class),
+                MAPPER.getTypeFactory().constructType(TestBean.class)
+                };
+        JavaType tupleType = MAPPER.getTypeFactory().constructTupleType(elementTypes);
+        ObjectReader tupleTypeReader = MAPPER.readerFor(tupleType);
+        String content = "[]";
+        JsonParser p = MAPPER.createParser(content);
+        List<Object> objectList = tupleTypeReader.readValue(p);
+        p.close();
+        assertEquals(0, objectList.size());
+        content = "[null,null,null,null,null]";
+        p = MAPPER.createParser(content);
+        objectList = tupleTypeReader.readValue(p);
+        p.close();
+        assertEquals(5, objectList.size());
+        content = "[1,2,3,null,{\"s\":1.23},"
+                + "[{\"@class\":\"" + getClass().getCanonicalName() + "$Circle\","
+                + "\"radius\":4},"
+                + "{\"@class\":\"" + getClass().getCanonicalName() + "$Rectangle\","
+                + "\"width\":5,\"height\":6}],"
+                + "{\"map1\":{\"a\":1},\"map2\":{\"a\":1}}]";
+        p = MAPPER.createParser(content);
+        objectList = tupleTypeReader.readValue(p);
+        p.close();
+        assertEquals(new Integer(1), objectList.get(0));
+        assertEquals(new BigDecimal("2"), objectList.get(1));
+        assertEquals(new Long(3), objectList.get(2));
+        assertEquals(null, objectList.get(3));
+        assertEquals(new BigDecimal("1.23"), ((Generic<BigDecimal>) objectList.get(4)).getT());
+        assertEquals(4, ((Circle) ((List<?>) objectList.get(5)).get(0)).getRadius());
+        assertEquals(5, ((Rectangle) ((List<?>) objectList.get(5)).get(1)).getWidth());
+        assertEquals(6, ((Rectangle) ((List<?>) objectList.get(5)).get(1)).getHeight());
+        assertEquals(100, ((TestBean) objectList.get(6)).getMap1().get("a").intValue());
+        assertEquals(1, ((TestBean) objectList.get(6)).getMap2().get("a").intValue());
+        Class<?>[] elementClazzs = new Class<?>[] {
+            Integer.class,
+            BigDecimal.class,
+            Long.class,
+            String.class
+        };
+        tupleType = MAPPER.getTypeFactory().constructTupleType(elementClazzs);
+        tupleTypeReader = MAPPER.readerFor(tupleType);
+        content = "[1,2,3,null]";
+        p = MAPPER.createParser(content);
+        objectList = tupleTypeReader.readValue(p);
+        p.close();
+        assertEquals(new Integer(1), objectList.get(0));
+        assertEquals(new BigDecimal("2"), objectList.get(1));
+        assertEquals(new Long(3), objectList.get(2));
+    }
+
+    @JsonDeserialize(using = Generic.CustomerDeserializer.class)
+    private static class Generic<T> {
+        private T t;
+
+        public T getT() {
+            return t;
+        }
+
+        public void setT(T t) {
+            this.t = t;
+        }
+
+        private static class CustomerDeserializer extends JsonDeserializer<Generic<?>>
+                implements ContextualDeserializer {
+
+            private Class<?> tClazz;
+
+            @SuppressWarnings("unused")
+            public CustomerDeserializer() {
+            }
+
+            public CustomerDeserializer(Class<?> tClazz) {
+                this.tClazz = tClazz;
+            }
+
+            @Override
+            public Generic<?> deserialize(JsonParser p, DeserializationContext ctxt)
+                    throws IOException, JacksonException {
+                JsonNode node = ctxt.readTree(p).findValue("s");
+                Generic<Object> g = new Generic<>();
+                Object t = ((ObjectMapper) p.getCodec()).convertValue(node, this.tClazz);
+                g.setT(t);
+                return g;
+            }
+
+            @Override
+            public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
+                    throws JsonMappingException {
+                JavaType currentType = null;
+                if (property == null) {
+                    // current type is root type.
+                    currentType = ctxt.getContextualType();
+                } else {
+                    // current type is wrapped in other type.
+                    currentType = property.getType();
+                }
+                Class<?> tClazz = currentType.getBindings().getBoundType(0).getRawClass();
+                return new CustomerDeserializer(tClazz);
+            }
+        }
+    }
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)
+    private static class Shape {
+
+    }
+
+    private static class Circle extends Shape {
+        private int radius;
+
+        public int getRadius() {
+            return radius;
+        }
+
+        @SuppressWarnings("unused")
+        public void setRadius(int radius) {
+            this.radius = radius;
+        }
+    }
+
+    private static class Rectangle extends Shape {
+        private int width;
+        private int height;
+
+        public int getWidth() {
+            return width;
+        }
+
+        @SuppressWarnings("unused")
+        public void setWidth(int width) {
+            this.width = width;
+        }
+
+        public int getHeight() {
+            return height;
+        }
+
+        @SuppressWarnings("unused")
+        public void setHeight(int height) {
+            this.height = height;
+        }
+    }
+    
+    @SuppressWarnings("unused")
+    private static class TestBean {
+
+        @JsonProperty("map1")
+        @JsonDeserialize(contentUsing = TestBeanCustomDeserializer.class)
+        Map<String, Integer> map1;
+
+        @JsonProperty("map2")
+        Map<String, Integer> map2;
+
+        public Map<String, Integer> getMap1() {
+            return map1;
+        }
+
+        public void setMap1(Map<String, Integer> map1) {
+            this.map1 = map1;
+        }
+
+        public Map<String, Integer> getMap2() {
+            return map2;
+        }
+
+        public void setMap2(Map<String, Integer> map2) {
+            this.map2 = map2;
+        }
+    }
+
+    private static class TestBeanCustomDeserializer extends StdDeserializer<Integer> {
+        private static final long serialVersionUID = 1L;
+
+        public TestBeanCustomDeserializer() {
+            super(Integer.class);
+        }
+
+        @Override
+        public Integer deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+            Integer value = p.readValueAs(Integer.class);
+            return value * 100;
+        }
+    }
 }