diff --git a/include/tvm/relay/expr.h b/include/tvm/relay/expr.h
index 1d2fa5472993f..18ec944f54f52 100644
--- a/include/tvm/relay/expr.h
+++ b/include/tvm/relay/expr.h
@@ -184,6 +184,26 @@ class VarNode : public ExprNode {
 
 RELAY_DEFINE_NODE_REF(Var, VarNode, Expr);
 
+/*! \brief Hash Var by it's id.
+ * Different VarNode might has same vid, and they are considered to be the same var in such case.
+ * Use VarHash to hash Var by id.
+ */
+struct VarHash {
+  size_t operator()(const Var& v) const {
+    return v->vid.hash();
+  }
+};
+
+/*! \brief Compare Var by it's id.
+ * Different VarNode might has same vid, and they are considered to be the same var in such case.
+ * Use VarEqual to compare Var by id.
+ */
+struct VarEqual {
+  bool operator()(const Var& l, const Var& r) const {
+    return l->vid.get() == r->vid.get();
+  }
+};
+
 /*!
  * \brief Global variable that leaves in the top-level module.
  * This is used to enable recursive calls between function.
@@ -521,7 +541,7 @@ RELAY_DEFINE_NODE_REF(RefWrite, RefWriteNode, Expr);
  * rewriting pass such as layout or type transformation.
  *
  * Subclass TempExprNode allows us to pattern match on
- * specific kind TempExpr and use them for expression rewriting.
+ * specific kind of TempExpr and use them for expression rewriting.
  *
  * TempExpr should only be used within a pass,
  */
@@ -539,6 +559,25 @@ class TempExprNode : public ExprNode {
 
 RELAY_DEFINE_NODE_REF(TempExpr, TempExprNode, Expr);
 
+class Annotate;
+class AnnotateNode : public ExprNode {
+ public:
+  Expr expr;
+  NodeRef annotation;
+  void VisitAttrs(tvm::AttrVisitor* v) final {
+    v->Visit("expr", &expr);
+    v->Visit("annotation", &annotation);
+    v->Visit("_checked_type_", &checked_type_);
+  }
+
+  TVM_DLL static Annotate make(Expr expr, NodeRef annotation);
+
+  static constexpr const char* _type_key = "relay.AnnotateNode";
+  TVM_DECLARE_NODE_TYPE_INFO(AnnotateNode, ExprNode);
+};
+
+RELAY_DEFINE_NODE_REF(Annotate, AnnotateNode, Expr);
+
 // implementataions
 inline const Type& ExprNode::checked_type() const {
   CHECK(checked_type_.defined()) << "internal error: the type checker has "
diff --git a/include/tvm/relay/expr_functor.h b/include/tvm/relay/expr_functor.h
index 3b179f8e53300..d3154d28bb272 100644
--- a/include/tvm/relay/expr_functor.h
+++ b/include/tvm/relay/expr_functor.h
@@ -116,6 +116,7 @@ class ExprFunctor<R(const Expr& n, Args...)> {
   virtual R VisitExpr_(const RefWriteNode* op, Args... args) EXPR_FUNCTOR_DEFAULT;
   virtual R VisitExpr_(const ConstructorNode* op, Args... args) EXPR_FUNCTOR_DEFAULT;
   virtual R VisitExpr_(const MatchNode* op, Args... args) EXPR_FUNCTOR_DEFAULT;
+  virtual R VisitExpr_(const AnnotateNode* op, Args... args) EXPR_FUNCTOR_DEFAULT;
   virtual R VisitExprDefault_(const Node* op, Args...) {
     throw Error(std::string("Do not have a default for ") + op->type_key());
   }
@@ -140,6 +141,7 @@ class ExprFunctor<R(const Expr& n, Args...)> {
     RELAY_EXPR_FUNCTOR_DISPATCH(RefWriteNode);
     RELAY_EXPR_FUNCTOR_DISPATCH(ConstructorNode);
     RELAY_EXPR_FUNCTOR_DISPATCH(MatchNode);
+    RELAY_EXPR_FUNCTOR_DISPATCH(AnnotateNode);
     return vtable;
   }
 };
@@ -170,6 +172,7 @@ class ExprVisitor
   void VisitExpr_(const RefWriteNode* op) override;
   void VisitExpr_(const ConstructorNode* op) override;
   void VisitExpr_(const MatchNode* op) override;
+  void VisitExpr_(const AnnotateNode* op) override;
   virtual void VisitType(const Type& t);
   virtual void VisitClause(const Clause& c);
   virtual void VisitPattern(const Pattern& c);
@@ -212,6 +215,7 @@ class ExprMutator
   Expr VisitExpr_(const RefWriteNode* op) override;
   Expr VisitExpr_(const ConstructorNode* op) override;
   Expr VisitExpr_(const MatchNode* op) override;
+  Expr VisitExpr_(const AnnotateNode* op) override;
 
   /*!
    * \brief Used to visit the types inside of expressions.
diff --git a/python/tvm/relay/network.py b/python/tvm/relay/network.py
new file mode 100644
index 0000000000000..cc3ca35b9b934
--- /dev/null
+++ b/python/tvm/relay/network.py
@@ -0,0 +1,159 @@
+import numpy as np
+import tvm
+from tvm import relay
+from tvm.relay import op
+from tvm.relay import create_executor, Module
+from tvm.relay.backend.interpreter import TensorValue
+from tvm.relay.prelude import Prelude
+import aot
+import collections
+
+class OrderedSet(collections.MutableSet):
+
+    def __init__(self, iterable=None):
+        self.end = end = []
+        end += [None, end, end]         # sentinel node for doubly linked list
+        self.map = {}                   # key --> [key, prev, next]
+        if iterable is not None:
+            self |= iterable
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        if key not in self.map:
+            end = self.end
+            curr = end[1]
+            curr[2] = end[1] = self.map[key] = [key, curr, end]
+
+    def discard(self, key):
+        if key in self.map:
+            key, prev, next = self.map.pop(key)
+            prev[2] = next
+            next[1] = prev
+
+    def __iter__(self):
+        end = self.end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    def pop(self):
+        key = self.last()
+        self.discard(key)
+        return key
+
+    def last(self):
+        return self.end[1][0]
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and list(self) == list(other)
+        return set(self) == set(other)
+
+def initialize(param):
+    ty = param.type_annotation
+    shape = [int(i) for i in ty.shape]
+    return np.random.normal(0, 1, shape).astype('float32')
+
+def copy_var(v):
+    return relay.Var(v.name_hint, v.type_annotation)
+
+class Network:
+    stack = []
+    cnt = 0
+
+    def __init__(self, *, name="f", **kwargs):
+        name = f"{name}_{Network.cnt}"
+        Network.cnt += 1
+        if len(Network.stack) is not 0:
+            mod = Network.stack[-1].mod
+            p = Network.stack[-1].p
+        else:
+            mod = Module()
+            p = Prelude(mod)
+
+        self.mod = mod
+        self.p = p
+        self.inputs = []
+        self.weights = OrderedSet()
+        self.sub_network = OrderedSet()
+        self.f = relay.GlobalVar(name)
+        self.recurse = relay.Var("recurse")
+        self.use_recurse = False
+        self.ret_type = None
+        body = self.build(**kwargs)
+        assert isinstance(body, relay.Expr)
+        if self.use_recurse:
+            inputs = [copy_var(v) for v in self.inputs]
+            body = relay.Let(self.recurse, relay.Function(inputs, self.call_from_outside(*inputs)), body)
+        self.mod[self.f] = relay.Function(self.inputs + self.all_weights(), body, self.ret_type)
+
+    def build(self, **kwargs):
+        Network.stack.append(self)
+        try:
+            return self.build_impl(**kwargs)
+        finally:
+            Network.stack.pop()
+
+    def build_impl(self, *args):
+        raise NotImplementedError
+
+    def weight(self, w):
+        assert isinstance(w, relay.Var)
+        self.weights.add(w)
+        return w
+
+    def input(self, i):
+        assert isinstance(i, relay.Var)
+        self.inputs.append(i)
+        return i
+
+    def all_weights(self):
+        return list(set(list(self.weights) + [w for n in self.sub_network for w in n.all_weights()]))
+
+    def call_from_outside(self, *inputs):
+        return self.f(*(list(inputs) + self.all_weights()))
+
+    def __call__(self, *inputs):
+        if self in Network.stack:
+            self.use_recurse = True
+            return self.recurse(*inputs)
+        else:
+            assert len(Network.stack) > 0
+            assert Network.stack[-1].mod == self.mod
+            assert Network.stack[-1].p == self.p
+            Network.stack[-1].sub_network.add(self)
+            return self.call_from_outside(*inputs)
+
+    def interface_type(self):
+        t = relay.ir_pass.infer_type(self.mod[self.f], mod=self.mod).checked_type
+        return relay.FuncType(t.arg_types[:len(self.inputs)], t.ret_type, t.type_params, t.type_constraints)
+
+    def get(self):
+        weights = []
+        for x in self.all_weights():
+            ty = x.type_annotation
+            assert isinstance(ty, relay.TensorType)
+            assert ty.dtype == 'float32'
+            shape = [int(i) for i in ty.shape]
+            weight = relay.const(np.random.normal(0, 1, shape).astype('float32'))
+            weights.append(weight)
+        inputs = [copy_var(v) for v in self.inputs]
+        return relay.Function(inputs, self.f(*inputs, *weights))
diff --git a/python/tvm/relay/op/nn/_nn.py b/python/tvm/relay/op/nn/_nn.py
index 5a47b1d42ed31..f1e3942743dbb 100644
--- a/python/tvm/relay/op/nn/_nn.py
+++ b/python/tvm/relay/op/nn/_nn.py
@@ -74,7 +74,7 @@ def schedule_batch_matmul(attrs, outputs, target):
     with target:
         return topi.generic.schedule_batch_matmul(outputs)
 
-reg.register_pattern("nn.batch_matmul", reg.OpPattern.OUT_ELEMWISE_FUSABLE)
+reg.register_pattern("nn.batch_matmul", reg.OpPattern.OPAQUE)
 
 
 # conv2d
diff --git a/python/tvm/relay/test_network.py b/python/tvm/relay/test_network.py
new file mode 100644
index 0000000000000..b84895503b784
--- /dev/null
+++ b/python/tvm/relay/test_network.py
@@ -0,0 +1,93 @@
+from .network import Network
+from tvm import relay
+from tvm.relay import op, var, Var, Function, Clause, PatternConstructor, PatternVar, Match
+from tvm.relay import TupleGetItem, Tuple, TensorType, TupleType
+
+class Linear(Network):
+    def build_impl(self, input_size, output_size, dtype="float32"):
+        x = self.input(var("linear_input", shape=(1, input_size), dtype=dtype))
+        w = self.weight(var("linear_weight", shape=(output_size, input_size), dtype=dtype))
+        b = self.weight(var("linear_bias", shape=(output_size,), dtype=dtype))
+        return op.add(op.nn.dense(x, w), b)
+
+def lam(names, func):
+    args = [Var(name) for name in names]
+    return Function(args, func(*args))
+
+class LSTMCell(Network):
+    def build_impl(self, input_size, memory_size, dtype="float32"):
+        t = TensorType(shape=(1, memory_size), dtype=dtype)
+        i = self.input(var("lstmcell_input", shape=(1, input_size), dtype=dtype))
+        c = self.input(Var("lstmcell_children", self.p.l(TupleType([t, t]))))
+        sum = lam(["x", "y"], lambda x, y: x + y)
+        child_h_sum = self.p.foldl(sum,
+                                   op.zeros(shape=(1, memory_size), dtype=dtype),
+                                   self.p.map(lam(["z"], lambda z: TupleGetItem(z, 1)), c))
+        ioux = Linear(input_size=input_size, output_size=memory_size * 3)(i)
+        iouh = Linear(input_size=memory_size, output_size=memory_size * 3)(child_h_sum)
+        iou = ioux + iouh
+        fx = Linear(input_size=input_size, output_size=memory_size)(i)
+        fh = Linear(input_size=memory_size, output_size=memory_size)
+        i, o, u = op.split(iou, 3, axis=1)
+        i, o, u = op.sigmoid(i), op.sigmoid(o), op.tanh(u)
+        def foreach_children(children):
+            f = op.sigmoid(fh(TupleGetItem(children, 1)) + fx)
+            return f * TupleGetItem(children, 0)
+        c = self.p.foldl(sum, i * u, self.p.map(lam(["z"], foreach_children), c))
+        return Tuple([c, o * op.tanh(c)])
+
+class LSTMEncoder(Network):
+    def build_impl(self, input_size, memory_size, dtype="float32"):
+        l = self.input(Var("l", self.p.l(TensorType(shape=(1, input_size), dtype=dtype))))
+        cell = LSTMCell(input_size=input_size, memory_size=memory_size, dtype=dtype)
+        return self.p.foldl(lam(["c", "x"], lambda c, x: cell(x, self.p.cons(c, self.p.nil()))),
+                            Tuple([op.zeros(shape=(1, memory_size), dtype=dtype),
+                                   op.zeros(shape=(1, memory_size), dtype=dtype)]), l)
+
+class LSTMTransformer(Network):
+    def build_impl(self, input_size, memory_size, dtype="float32"):
+        l = self.input(Var("l", self.p.l(TensorType(shape=(1, input_size), dtype=dtype))))
+        def f(c, x):
+            cell = LSTMCell(input_size=input_size, memory_size=memory_size, dtype=dtype)
+            o = cell(x, self.p.cons(c, self.p.nil()))
+            return Tuple([o, TupleGetItem(o, 1)])
+        res = self.p.map_accuml(lam(["c", "x"], f),
+                                 Tuple([op.zeros(shape=(1, memory_size), dtype=dtype),
+                                        op.zeros(shape=(1, memory_size), dtype=dtype)]),
+                                 l)
+        return Tuple([TupleGetItem(TupleGetItem(res, 0), 1), TupleGetItem(res, 1)])
+
+class TreeLSTM(Network):
+    def build_impl(self, input_size, memory_size, dtype="float32"):
+        t = TensorType(shape=(1, memory_size), dtype=dtype)
+        self.ret_type = TupleType([t, t])
+        tree_type = self.p.tree(TensorType(shape=(1, input_size), dtype=dtype))
+        t = self.input(Var("tlstm_input", tree_type))
+        i = Var("i", TensorType(shape=(1, input_size), dtype=dtype))
+        c = Var("c", self.p.l(tree_type))
+        cell = LSTMCell(input_size=input_size, memory_size=memory_size, dtype=dtype)
+        rose_case = Clause(PatternConstructor(self.p.rose, [PatternVar(i), PatternVar(c)]),
+                           cell(i, self.p.map(lam(["x"], self), c)))
+        return Match(t, [rose_case])
+
+class BiLSTM(Network):
+    def build_impl(self, input_size, memory_size, dtype="float32"):
+        l = self.input(Var("l", self.p.l(TensorType(shape=(1, input_size), dtype=dtype))))
+        def LSTM(l):
+            return LSTMTransformer(input_size=input_size,
+                                   memory_size=memory_size,
+                                   dtype=dtype)(l)
+        fwd = LSTM(l)
+        rev = LSTM(self.p.rev(l))
+        lhs = op.concatenate([TupleGetItem(fwd, 0), TupleGetItem(rev, 0)], axis=1)
+        t = TensorType(shape=(1, memory_size), dtype=dtype)
+        x = Var("x", TupleType([t, t])) # cannot infer here
+        rhs = self.p.map(Function([x], op.concatenate([TupleGetItem(x, 0),
+                                                       TupleGetItem(x, 1)],
+                                                      axis=1)),
+                         self.p.zip(TupleGetItem(fwd, 1), TupleGetItem(rev, 1)))
+        return Tuple([lhs, rhs])
+
+# t = BiLSTM(input_size=128, memory_size=256)
+# print("type of BidirectionalLSTM, with input_size=128, memory_size=256, is:")
+# print(t.interface_type())
diff --git a/src/relay/ir/expr.cc b/src/relay/ir/expr.cc
index 3108bc2501fed..422163758a2f2 100644
--- a/src/relay/ir/expr.cc
+++ b/src/relay/ir/expr.cc
@@ -232,8 +232,7 @@ TVM_REGISTER_API("relay._make.Call")
 
 TVM_STATIC_IR_FUNCTOR_REGISTER(IRPrinter, vtable)
 .set_dispatch<CallNode>([](const CallNode* node, tvm::IRPrinter* p) {
-  p->stream << "CallNode(" << node->op << ", " << node->args << ", "
-    << node->attrs << ", " << node->type_args << ")";
+  p->stream << "CallNode(" << node->op << ")";
 });
 
 Let LetNode::make(Var var, Expr value, Expr body) {
@@ -349,5 +348,17 @@ TVM_REGISTER_API("relay._expr.TempExprRealize")
   *ret = temp->Realize();
 });
 
+Annotate AnnotateNode::make(Expr expr, NodeRef annotation) {
+  NodePtr<AnnotateNode> n = make_node<AnnotateNode>();
+  n->expr = std::move(expr);
+  n->annotation = std::move(annotation);
+  return Annotate(n);
+}
+
+TVM_STATIC_IR_FUNCTOR_REGISTER(IRPrinter, vtable)
+.set_dispatch<AnnotateNode>([](const AnnotateNode* node, tvm::IRPrinter* p) {
+    p->stream << "AnnotateNode(" << node->expr << ")";
+  });
+
 }  // namespace relay
 }  // namespace tvm
diff --git a/src/relay/ir/expr_functor.cc b/src/relay/ir/expr_functor.cc
index d0cd30adda29f..aaaf34d261a17 100644
--- a/src/relay/ir/expr_functor.cc
+++ b/src/relay/ir/expr_functor.cc
@@ -221,6 +221,10 @@ Pattern ExprMutator::VisitPattern(const Pattern& p) { return p; }
 
 Type ExprMutator::VisitType(const Type& t) { return t; }
 
+Expr ExprMutator::VisitExpr_(const AnnotateNode* op) {
+  return AnnotateNode::make(VisitExpr(op->expr), op->annotation);
+}
+
 void ExprVisitor::VisitExpr(const Expr& expr) {
   auto it = visit_counter_.find(expr.get());
   if (it != visit_counter_.end()) {
@@ -315,6 +319,10 @@ void ExprVisitor::VisitExpr_(const MatchNode* op) {
   }
 }
 
+void ExprVisitor::VisitExpr_(const AnnotateNode* op) {
+  this->VisitExpr(op->expr);
+}
+
 void ExprVisitor::VisitClause(const Clause& op) {
   this->VisitPattern(op->lhs);
   this->VisitExpr(op->rhs);
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 969f08b32e830..2b043fc7f4189 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -585,6 +585,24 @@ class PrettyPrinter :
     return doc << "), " << PrintDType(node->dtype) << "]";
   }
 
+  Doc VisitType_(const GlobalTypeVarNode* node) final {
+    Doc doc;
+    doc << node->var->name_hint;
+    return doc;
+  }
+
+  Doc VisitType_(const TypeCallNode* node) final {
+    Doc doc = PrintType(node->func, false);
+    std::vector<Doc> args;
+    for (const Type& t : node->args) {
+      args.push_back(PrintType(t, false));
+    }
+    doc << "(";
+    doc << PrintVec(args);
+    doc << ")";
+    return doc;
+  }
+
   Doc VisitType_(const TupleTypeNode* node) final {
     std::vector<Doc> fields;
     for (Type field : node->fields) {
diff --git a/src/relay/ir/type.cc b/src/relay/ir/type.cc
index fb0d919b46c38..718bad63693b1 100644
--- a/src/relay/ir/type.cc
+++ b/src/relay/ir/type.cc
@@ -113,6 +113,7 @@ TVM_STATIC_IR_FUNCTOR_REGISTER(IRPrinter, vtable)
 });
 
 TypeCall TypeCallNode::make(Type func, tvm::Array<Type> args) {
+  CHECK(func.as<GlobalTypeVarNode>());
   NodePtr<TypeCallNode> n = make_node<TypeCallNode>();
   n->func = std::move(func);
   n->args = std::move(args);
diff --git a/src/relay/op/nn/nn.cc b/src/relay/op/nn/nn.cc
index d24431347f808..c2f24e2179bef 100644
--- a/src/relay/op/nn/nn.cc
+++ b/src/relay/op/nn/nn.cc
@@ -683,7 +683,7 @@ bool BatchMatmulRel(const Array<Type>& types,
   const auto* x = types[0].as<TensorTypeNode>();
   const auto* y = types[1].as<TensorTypeNode>();
   if (x == nullptr || y == nullptr) return false;
-  if (x->shape.size() != 3 || y->shape.size() != 3) return false;
+  CHECK (x->shape.size() == 3 && y->shape.size() == 3);
   CHECK(reporter->AssertEQ(x->shape[0], y->shape[0]))
       << "BatchDot: batch dimension doesn't match, "
       << " x shape=" << x->shape
diff --git a/src/relay/op/tensor/transform.cc b/src/relay/op/tensor/transform.cc
index f86156bdbddcd..0f83f2cf194f2 100644
--- a/src/relay/op/tensor/transform.cc
+++ b/src/relay/op/tensor/transform.cc
@@ -729,9 +729,19 @@ bool TakeRel(const Array<Type>& types,
   // `types` contains: [data, indices, result]
   CHECK_EQ(types.size(), 3);
   const auto* data = types[0].as<TensorTypeNode>();
-  CHECK(data != nullptr);
+  if (data == nullptr) {
+    CHECK(types[0].as<IncompleteTypeNode>())
+      << "must be tensor type or incomplete type";
+    return false;
+  }
+
   const auto* indices = types[1].as<TensorTypeNode>();
-  CHECK(indices != nullptr);
+  if (indices == nullptr) {
+    CHECK(types[1].as<IncompleteTypeNode>())
+      << "must be tensor type or incomplete type";
+    return true;
+  }
+
   const auto param = attrs.as<TakeAttrs>();
   CHECK(param != nullptr);
 
diff --git a/src/relay/pass/dead_code.cc b/src/relay/pass/dead_code.cc
index 06cd9091749bc..091e7cf836033 100644
--- a/src/relay/pass/dead_code.cc
+++ b/src/relay/pass/dead_code.cc
@@ -1,22 +1,3 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- * 
- *   http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
 /*!
  * Copyright (c) 2018 by Contributors
  *
@@ -27,28 +8,278 @@
  * The algorithm is implemented by two visitor:
  * CalcDep turn an expr into a dependency graph of expr,
  * GenLet turn the dependency graph into a let list, taking only the used value.
+ *
+ * Also, Dead Code Eliminator has to take into account of effect -
+ * Call to foreign function should not be eliminated.
+ * Write to reference should not be eliminated if that reference is used.
+ *
+ * To do this we implement a simple escape analysis.
+ * We abstract Reference Value point to StoreId.
+ * Each RefCreate get a unique StoreId,
+ * And also assign each parameter a unique StoreId (as they might has/contain Ref).
+ * We then create a map of Expr -> Set StoreId, which record what StoreId Expr might depend on.
+ * The map is ran until a Fixpoint (it will terminate as there are finite StoreId.).
+ * The StoreId inside the inputs and the body are all the StoreId that is alive,
+ * and effect to other StoreId can be removed.
+ *
+ * We choose to implement StoreId as Expr for simplicity.
+ *
+ * Whenever a function is called, or a reference is written into,
+ * We make the set of reference inside depend on that call/write.
  */
 #include <tvm/relay/pass.h>
 #include <tvm/relay/expr_functor.h>
+#include <tvm/relay/pattern_functor.h>
 #include "let_list.h"
 
 namespace tvm {
 namespace relay {
 
+using Sid = Expr;
+using SidSet = std::unordered_set<Sid, NodeHash, NodeEqual>;
+using ExprSet = std::unordered_set<Expr, NodeHash, NodeEqual>;
+template<typename T>
+using ExprMap = std::unordered_map<Expr, T, NodeHash, NodeEqual>;
+template<typename X>
+using VarMap = std::unordered_map<Var, X, VarHash, VarEqual>;
+using VarSet = std::unordered_set<Var, VarHash, VarEqual>;
+
+struct EscapeAnalysis : ExprFunctor<void(const Expr&, const Expr&)>,
+                        PatternFunctor<void(const Pattern&, const Expr&)> {
+  ExprMap<SidSet> map_;
+  SidSet live_sid_;
+  ExprSet root_expr_;
+  bool converge = false;
+  bool HasEffect(const Expr& e) {
+    struct EffectVisitor : ExprVisitor {
+      EscapeAnalysis* ea_;
+      explicit EffectVisitor(EscapeAnalysis* ea) : ea_(ea) { }
+      bool has_effect = false;
+      void Touch(const Expr& e) {
+        for (const Sid& s: ea_->Get(e)) {
+          has_effect |= (ea_->live_sid_.count(s) > 0);
+          if (ea_->live_sid_.count(s) > 0) {
+            std::cout << "HAS EFFECT" << std::endl;
+            return;
+          }
+        }
+      }
+      void VisitExpr_(const RefReadNode* op) final {
+        Touch(op->ref);
+        VisitExpr(op->ref);
+      }
+      void VisitExpr_(const RefWriteNode* op) final {
+        Touch(op->ref);
+        VisitExpr(op->ref);
+        VisitExpr(op->value);
+      }
+      void VisitExpr_(const CallNode* op) final {
+        // The args contain same sid as op, so no need to touch them.
+        Touch(op->op);
+        VisitExpr(op->op);
+        for (const Expr& arg: op->args) {
+          VisitExpr(arg);
+        }
+      }
+      void VisitExpr_(const FunctionNode* op) final { }
+    };
+    std::cout << "CHECK EFFECT:" << e << std::endl;
+    EffectVisitor ev(this);
+    ev(e);
+    return ev.has_effect;
+  }
+  explicit EscapeAnalysis(const Expr& e) {
+    for (const Var& v: FreeVars(e)) {
+      AllocRoot(v);
+    }
+    while (!converge) {
+      converge = true;
+      Analysis(e);
+    }
+    Alive(e);
+    for (const Expr& r: root_expr_) {
+      Alive(r);
+    }
+    while (!converge) {
+      converge = true;
+      std::vector<Sid> live_sid_old;
+      for (const Sid& s: live_sid_) {
+        live_sid_old.push_back(s);
+      }
+      for (const Sid& s: live_sid_old) {
+        Alive(s);
+      }
+    }
+  }
+  void Alive(const Expr& e) {
+    for (const Sid& s: Get(e)) {
+      if (live_sid_.count(s) == 0) {
+        converge = false;
+        live_sid_.insert(s);
+      }
+    }
+  }
+  void Analysis(const Expr& e) {
+    VisitExpr(e, e);
+  }
+  ExprSet& Get(const Expr& e) {
+    if (map_.count(e) == 0) {
+      map_.insert({e, ExprSet()});
+    }
+    return map_.at(e);
+  }
+  std::vector<Sid> Range(const Expr& e) {
+    std::vector<Sid> ret;
+    for (const auto& x: Get(e)) {
+      ret.push_back(x);
+    }
+    return ret;
+  }
+  void Insert(const Expr& from, const Expr& to) {
+    ExprSet& x = Get(from);
+    if (x.count(to) == 0) {
+      converge = false;
+      x.insert(to);
+    }
+  }
+  void Join(const Expr& from, const Expr& to) {
+    for (const Expr& e: Range(to)) {
+      Insert(from, e);
+    }
+  }
+  void Write(const Expr& from, const Expr& to) {
+    for (const Expr& e: Range(from)) {
+      Join(e, to);
+    }
+  }
+  void Alloc(const Expr& e) {
+    Insert(e, e);
+  }
+  void Root(const Expr& e) {
+    root_expr_.insert(e);
+  }
+  void AllocRoot(const Expr& e) {
+    Alloc(e);
+    Root(e);
+  }
+  void Depend(const Expr& val, const Expr& on) {
+    Analysis(on);
+    Join(val, on);
+  }
+  void VisitExpr_(const RefCreateNode* op, const Expr& e) final {
+    AllocRoot(e);
+    Depend(e, op->value);
+  }
+  void VisitExpr_(const RefWriteNode* op, const Expr& e) final {
+    Write(e, op->ref);
+    Analysis(op->ref);
+    Analysis(op->value);
+  }
+  void VisitExpr_(const FunctionNode* op, const Expr& e) final {
+    for (const Var& v: op->params) {
+      AllocRoot(v);
+    }
+    Root(op->body);
+    Depend(e, op->body);
+  }
+  void VisitExpr_(const CallNode* op, const Expr& e) final {
+    std::vector<Expr> exprs;
+    Depend(e, op->op);
+    exprs.push_back(op->op);
+    for (const Expr& arg: op->args) {
+      Depend(e, arg);
+      exprs.push_back(arg);
+    }
+    for (size_t i = 0; i < exprs.size(); ++i) {
+      for (size_t j = i + 1; j < exprs.size(); ++j) {
+        Write(exprs[i], exprs[j]);
+        Write(exprs[j], exprs[i]);
+      }
+    }
+  }
+  void RecordVar(const Var& v) {
+    Get(v);
+  }
+  void VisitExpr_(const LetNode* op, const Expr& e) final {
+    RecordVar(op->var);
+    Depend(op->var, op->value);
+    Depend(e, op->body);
+  }
+  // From here on the uninteresting case: just declare Depend on children
+  void VisitExpr_(const VarNode* op, const Expr& e) final {
+    CHECK_GT(map_.count(GetRef<Expr>(op)), 0);
+  }
+  void VisitExpr_(const ConstructorNode* op, const Expr& e) final { }
+  void VisitExpr_(const OpNode* op, const Expr& e) final {
+    // TODO(@M.K.): handle stateful op
+  }
+  void VisitExpr_(const ConstantNode* op, const Expr& e) final { }
+  void VisitExpr_(const GlobalVarNode* op, const Expr& e) final { }
+  void VisitExpr_(const MatchNode* op, const Expr& e) final {
+    Depend(e, op->data);
+    for (const Clause& c: op->clauses) {
+      VisitPattern(c->lhs, op->data);
+      Depend(e, c->rhs);
+    }
+  }
+  void VisitPattern_(const PatternWildcardNode* op, const Expr& e) final { }
+  void VisitPattern_(const PatternVarNode* op, const Expr& e) final {
+    Depend(op->var, e);
+  }
+  void VisitPattern_(const PatternConstructorNode* op, const Expr& e) final {
+    for (const Pattern& pat: op->patterns) {
+      VisitPattern(pat, e);
+    }
+  }
+  void VisitExpr_(const RefReadNode* op, const Expr& e) final {
+    Depend(e, op->ref);
+  }
+  void VisitExpr_(const TupleNode* op, const Expr& e) final {
+    for (const Expr& c: op->fields) {
+      Depend(e, c);
+    }
+  }
+  void VisitExpr_(const TupleGetItemNode* op, const Expr& e) final {
+    Depend(e, op->tuple);
+  }
+  void VisitExpr_(const IfNode* op, const Expr& e) final {
+    Depend(e, op->cond);
+    Depend(e, op->true_branch);
+    Depend(e, op->false_branch);
+  }
+};
+
+
 // calculate the dependency graph from expression
 class CalcDep : private ExprVisitor {
  public:
-  static Expr Eliminate(const Expr& e) {
-    CalcDep cd;
-    cd.Calculate(e);
-    Eliminator el(cd.expr_map_, cd.use_map_, cd.letrec_set_);
-    return el(e);
+  explicit CalcDep(const Expr& v) {
+    VisitExpr(v);
+    return;
+    count_ = false;
+    while (!dead_worklist_.empty()) {
+      Var dead = *(dead_worklist_.begin());
+      dead_worklist_.erase(dead);
+      CHECK_EQ(use_map_[dead], 0);
+      if (expr_map_.count(dead) > 0) {
+        LetRec([&]() { VisitExpr(expr_map_[dead]); }, dead);
+      }
+    }
+  }
+
+  bool Used(const Var& v) {
+    return use_map_[v] > 0;
+  }
+
+  bool HasLet(const Var& v) {
+    return (use_map_[v] > 1 || (use_map_[v] != 0 && letrec_set_.count(v) != 0));
+  }
+
+  Expr Map(const Var& v) {
+    return expr_map_.count(v) == 0 ? Expr(v) : expr_map_[v];
   }
 
  private:
-  template<typename X>
-  using VarMap = std::unordered_map<Var, X, NodeHash, NodeEqual>;
-  using VarSet = std::unordered_set<Var, NodeHash, NodeEqual>;
   VarMap<Expr> expr_map_;
   VarMap<size_t> use_map_;
   VarSet letrec_set_;
@@ -98,53 +329,43 @@ class CalcDep : private ExprVisitor {
       letrec_set_.insert(var);
     }
   }
+};
 
-  void Calculate(const Expr& v) {
-    VisitExpr(v);
-    count_ = false;
-    while (!dead_worklist_.empty()) {
-      Var dead = *(dead_worklist_.begin());
-      dead_worklist_.erase(dead);
-      CHECK_EQ(use_map_[dead], 0);
-      if (expr_map_.count(dead) > 0) {
-        LetRec([&]() { VisitExpr(expr_map_[dead]); }, dead);
-      }
-    }
+class Eliminator : private ExprMutator {
+ public:
+  static Expr Eliminate(const Expr& e) {
+    Eliminator elm(e);
+    return elm(e);
   }
+ private:
+  EscapeAnalysis ea_;
+  CalcDep cd_;
+  explicit Eliminator(const Expr& e) : ea_(e), cd_(e) { }
+  friend CalcDep;
 
-  class Eliminator : private ExprMutator {
-   private:
-    VarMap<Expr> expr_map_;
-    VarMap<size_t> use_map_;
-    VarSet letrec_set_;
-    explicit Eliminator(const VarMap<Expr>& expr_map,
-                        const VarMap<size_t>& use_map,
-                        const VarSet& letrec_set) :
-      expr_map_(expr_map), use_map_(use_map), letrec_set_(letrec_set) { }
-    friend CalcDep;
-
-    bool HasLet(const Var& v) {
-      return (use_map_[v] > 1 || (use_map_[v] != 0 && letrec_set_.count(v) != 0));
-    }
-
-    Expr VisitExpr_(const VarNode* op) final {
-      Var v = GetRef<Var>(op);
-      return (expr_map_.count(v) == 0 || HasLet(v)) ? v : VisitExpr(expr_map_[v]);
-    }
+  Expr VisitExpr_(const VarNode* op) final {
+    Var v = GetRef<Var>(op);
+    return v;
+    std::cout << v << " map to " << cd_.Map(v) << std::endl;
+    return (cd_.Used(v) || ea_.HasEffect(cd_.Map(v))) ? v : cd_.Map(v);
+  }
 
-    Expr VisitExpr_(const LetNode* op) final {
-      Var v = op->var;
-      if (HasLet(v)) {
-        return LetNode::make(v, VisitExpr(op->value), VisitExpr(op->body));
-      } else {
-        return VisitExpr(op->body);
-      }
+  Expr VisitExpr_(const LetNode* op) final {
+    Var v = op->var;
+    CHECK_EQ(cd_.Map(v), op->value);
+    if (cd_.Used(v) || ea_.HasEffect(op->value)) {
+      return LetNode::make(v, VisitExpr(op->value), VisitExpr(op->body));
+    } else {
+      return VisitExpr(op->body);
     }
-  };
+  }
+  //Expr VisitExpr_(const IfNode* op) final {
+  //  return IfNode::make(op->cond, Descend(op->true_branch), Descend(op->false_branch));
+  //}
 };
 
 Expr DeadCodeElimination(const Expr& e) {
-  return CalcDep::Eliminate(e);
+  return Eliminator::Eliminate(e);
 }
 
 TVM_REGISTER_API("relay._ir_pass.dead_code_elimination")
diff --git a/src/relay/pass/partial_eval.cc b/src/relay/pass/partial_eval.cc
index f6283d380176a..63ad11d2e1182 100644
--- a/src/relay/pass/partial_eval.cc
+++ b/src/relay/pass/partial_eval.cc
@@ -1,22 +1,3 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- * 
- *   http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
 /*!
  * Copyright (c) 2018 by Contributors
  *
@@ -104,6 +85,7 @@
 #include <tvm/relay/expr_functor.h>
 #include <tvm/relay/pattern_functor.h>
 #include <tvm/relay/interpreter.h>
+#include "../ir/type_functor.h"
 #include "pass_util.h"
 #include "let_list.h"
 
@@ -112,26 +94,7 @@ namespace relay {
 
 using namespace runtime;
 
-/*! \brief Hash Var by it's id.
- * Different VarNode might has same vid, and they are considered to be the same var in such case.
- * Use VarHash to hash Var by id.
- */
-struct VarHash {
-  size_t operator()(const Var& v) const {
-    return v->vid.hash();
-  }
-};
-
-/*! \brief Compare Var by it's id.
- * Different VarNode might has same vid, and they are considered to be the same var in such case.
- * Use VarEqual to compare Var by id.
- */
-struct VarEqual {
-  bool operator()(const Var& l, const Var& r) const {
-    return l->vid.get() == r->vid.get();
-  }
-};
-
+Expr PostProcess(const Expr&);
 /*! \brief The base container type of Relay values. */
 class StaticNode : public RelayNode {
  public:
@@ -150,10 +113,20 @@ class Static : public NodeRef {
   using ContainerType = StaticNode;
 };
 
+using Time = size_t;
+
 struct PStaticNode : Node {
+  static Time time() {
+    static Time time_ = 0;
+    Time ret = time_;
+    time_++;
+    return ret;
+  }
   Static pstatic;  // may be null
   Expr dynamic;
-  PStaticNode(const Static& pstatic, const Expr& dynamic) : pstatic(pstatic), dynamic(dynamic) { }
+  Time created_time;
+  PStaticNode(const Static& pstatic, const Expr& dynamic) :
+    pstatic(pstatic), dynamic(dynamic), created_time(time()) { }
   explicit PStaticNode(const Expr& dynamic) : PStaticNode(Static(), dynamic) { }
   TVM_DECLARE_NODE_TYPE_INFO(PStaticNode, Node);
 };
@@ -261,7 +234,7 @@ class Environment {
       }
       ++rit;
     }
-    LOG(FATAL) << "Unknown Variable: " << v;
+    LOG(FATAL) << "Unknown Variable: " << v << v.as<VarNode>();
     throw;
   }
 
@@ -341,6 +314,7 @@ class Store {
 };
 
 PStatic HasStatic(const Static& stat, const Expr& dynamic) {
+  CHECK(stat.defined());
   return PStatic(make_node<PStaticNode>(stat, dynamic));
 }
 
@@ -383,15 +357,61 @@ FInterpreter CPUInterpreter() {
   return CreateInterpreter(Module(nullptr), CPUContext(), target);
 }
 
-class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>,
+bool IsAtomic(const Expr& e) {
+  return e.as<VarNode>() || e.as<OpNode>() || e.as<ConstructorNode>() || e.as<GlobalVarNode>();
+}
+
+using FuncId = size_t;
+
+struct WithFuncId;
+
+struct WithFuncIdNode : Node {
+  FuncId fid;
+  WithFuncIdNode(FuncId fid) : fid(fid) { }
+  static constexpr const char* _type_key = "relay.WithFuncId";
+  TVM_DECLARE_NODE_TYPE_INFO(WithFuncIdNode, Node);
+};
+
+RELAY_DEFINE_NODE_REF(WithFuncId, WithFuncIdNode, NodeRef);
+
+Annotate MkWithFuncId(const Expr& expr, FuncId fid) {
+  return AnnotateNode::make(expr, WithFuncId(make_node<WithFuncIdNode>(fid)));
+}
+
+Expr StripWithFuncId(const Expr& e);
+
+Expr DeDup(const Expr& e);
+
+Function AsFunc(const Expr& e) {
+  if (e.as<FunctionNode>()) {
+    return Downcast<Function>(e);
+  } else if (const AnnotateNode* a = e.as<AnnotateNode>()) {
+    CHECK(a->annotation.as<WithFuncIdNode>());
+    return AsFunc(a->expr);
+  } else {
+    LOG(FATAL) << "Unknown case";
+    throw;
+  }
+}
+
+class PartialEvaluator : public ExprFunctor<PStatic(const Expr&, LetList*)>,
                          public PatternFunctor<MatchStatus(const Pattern&, const PStatic&)> {
  public:
-  PartialEvaluator(const tvm::Array<Var>& free_vars) {
+  PartialEvaluator(const tvm::Array<Var>& free_vars,
+                   const Module& mod) :
+    mod_(mod) {
     for (const Var& v : free_vars) {
       env_.Insert(v, NoStatic(v));
     }
   }
 
+  size_t depth = 0;
+  PStatic VisitExpr(const Expr& e, LetList* ll) final {
+    PStatic ret = ExprFunctor<PStatic(const Expr&, LetList*)>::VisitExpr(e, ll);
+    CHECK(IsAtomic(ret->dynamic)) << ret->dynamic;
+    return ret;
+  }
+
   PStatic VisitExpr_(const ConstantNode* op, LetList* ll) final {
     return HasStatic(MkSTensor(op->data.CopyTo(context_)), ll->Push(GetRef<Expr>(op)));
   }
@@ -421,7 +441,20 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
   }
 
   PStatic VisitExpr_(const GlobalVarNode* op, LetList* ll) final {
-    return NoStatic(GetRef<Expr>(op));
+    GlobalVar gv = GetRef<GlobalVar>(op);
+    if (gv_map_.count(gv) == 0) {
+      if (mod_.defined()) {
+        Function func = mod_->Lookup(gv);
+        InitializeFuncId(func);
+        Func f = VisitFuncStatic(func, gv);
+        gv_map_.insert({gv, HasStatic(MkSFunc(f), gv)});
+        func = AsFunc(PostProcess(VisitFuncDynamic(func, f)));
+        mod_->Update(gv, func);
+      } else {
+        gv_map_.insert({gv, NoStatic(gv)});
+      }
+    }
+    return gv_map_.at(gv);
   }
 
   PStatic VisitExpr_(const LetNode* op, LetList* ll) final {
@@ -501,19 +534,45 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
     }
   }
 
-  PStatic VisitExpr_(const FunctionNode* op, LetList* ll) final {
-    Function func = GetRef<Function>(op);
+  PStatic VisitExpr_(const AnnotateNode* op, LetList* ll) final {
+    CHECK(op->annotation.as<WithFuncIdNode>());
+    return VisitExpr(op->expr, ll);
+  }
+
+  struct TimeFrame {
+    PartialEvaluator* pe_;
+    FuncId fid_;
+    std::vector<Time> old_time;
+    bool has_old_time;
+    TimeFrame(PartialEvaluator* pe,
+              FuncId fid,
+              const std::vector<Time>& args_time) : pe_(pe), fid_(fid) {
+      has_old_time = pe_->time_map_.count(fid_) > 0;
+      old_time = pe_->time_map_[fid_];
+      pe_->time_map_[fid_] = args_time;
+    }
+    ~TimeFrame() {
+      if (has_old_time) {
+        pe_->time_map_[fid_] = old_time;
+      } else {
+        pe_->time_map_.erase(fid_);
+      }
+    }
+  };
+
+  Func VisitFuncStatic(const Function& func, const Expr& var) {
+    CHECK(IsAtomic(var));
     if (func->IsPrimitive()) {
-      return HasStatic(MkSFunc(ConstEvaluateFunc(func, ll)), func);
+      return ConstEvaluateFunc(func);
     }
     std::vector<std::pair<Var, PStatic> > free_vars;
-    for (const auto& v : FreeVars(GetRef<Expr>(op))) {
+    for (const auto& v : FreeVars(func)) {
       free_vars.push_back(std::pair<Var, PStatic>(v, env_.Lookup(v)));
     }
-    Func f = [=](const std::vector<PStatic>& pv,
-                 const Attrs& attrs,
-                 const tvm::Array<Type>& type_args,
-                 LetList* ll) {
+    return [=](const std::vector<PStatic>& pv,
+               const Attrs& attrs,
+               const tvm::Array<Type>& type_args,
+               LetList* ll) {
       return env_.Extend<PStatic>([&]() {
           CHECK_EQ(pv.size(), func->params.size());
           for (size_t i = 0; i < pv.size(); ++i) {
@@ -529,10 +588,44 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
           for (size_t i = type_args.size(); i < func->type_params.size(); ++i) {
             subst.Set(func->type_params[i], Type());
           }
-          return VisitExpr(TypeSubst(func->body, subst), ll);
+          std::vector<Time> args_time;
+          for (const auto& v : pv) {
+            args_time.push_back(v->created_time);
+          }
+          CHECK_GT(func_map_.count(func), 0);
+          FuncId fid = func_map_.at(func);
+          auto recurse = [&]() {
+            TimeFrame tf(this, fid, args_time);
+            return VisitExpr(RegisterFuncId(TypeSubst(AnnotateFuncId(func->body), subst)), ll);
+          };
+          if (time_map_.count(fid) == 0) {
+            return recurse();
+          } else {
+            bool can_recurse = false;
+            std::vector<Time>& min_time = time_map_.at(fid);
+            CHECK_EQ(args_time.size(), min_time.size());
+            for (size_t i = 0; i < args_time.size(); ++i) {
+              if (args_time[i] < min_time[i]) {
+                can_recurse = true;
+              }
+              args_time[i] = std::min(args_time[i], min_time[i]);
+            }
+            if (can_recurse) {
+              return recurse();
+            } else {
+              std::vector<Expr> dyn;
+              for (const auto& v : pv) {
+                dyn.push_back(v->dynamic);
+              }
+              return NoStatic(ll->Push(CallNode::make(var, dyn, attrs, type_args)));
+            }
+          }
         });
     };
-    Expr dyn = store_.Extend<Expr>([&]() {
+  }
+
+  Expr VisitFuncDynamic(const Function& func, const Func& f) {
+    return store_.Extend<Expr>([&]() {
         store_.Invalidate();
         return FunctionNode::make(func->params, LetList::With([&](LetList* ll) {
               std::vector<PStatic> pv;
@@ -546,7 +639,21 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
               return f(pv, Attrs(), type_args, ll)->dynamic;
             }), func->ret_type, func->type_params, func->attrs);
       });
-    return HasStatic(MkSFunc(f), ll->Push(dyn));
+  }
+
+  PStatic VisitFunc(const Function& func, LetList* ll) {
+    Var v = VarNode::make("x", Type());
+    Func f = VisitFuncStatic(func, v);
+    Function u_func = AsFunc(RegisterFuncId(DeDup(AnnotateFuncId(func))));
+    // TODO(@M.K.): we seems to reduce landin knot into letrec.
+    // restore letrec support across whole relay.
+    return HasStatic(MkSFunc(f),
+                     ll->Push(v, VisitFuncDynamic(u_func, f)));
+  }
+
+  PStatic VisitExpr_(const FunctionNode* op, LetList* ll) final {
+    Function func = GetRef<Function>(op);
+    return VisitFunc(func, ll);
   }
 
   Expr Reflect(const PStatic& st) {
@@ -590,7 +697,8 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
     return Reify(executor_(fused_infered), ll);
   }
 
-  Func ConstEvaluateFunc(const Expr& expr, LetList* ll) {
+  Func ConstEvaluateFunc(const Expr& expr) {
+    CHECK(FreeVars(expr).size() == 0);
     return [=](const std::vector<PStatic>& pv,
                const Attrs& attrs,
                const tvm::Array<Type>& type_args,
@@ -599,7 +707,7 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
       for (const PStatic& ps : pv) {
         ns_args.push_back(ps->dynamic);
       }
-      PStatic ns = NoStatic(CallNode::make(expr, ns_args, attrs, type_args));
+      PStatic ns = NoStatic(ll->Push(CallNode::make(expr, ns_args, attrs, type_args)));
       if (StatefulOp(expr)) {
         return ns;
       }
@@ -616,7 +724,7 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
   }
 
   PStatic VisitExpr_(const OpNode* op, LetList* ll) final {
-    return HasStatic(MkSFunc(ConstEvaluateFunc(GetRef<Expr>(op), ll)), GetRef<Expr>(op));
+    return HasStatic(MkSFunc(ConstEvaluateFunc(GetRef<Expr>(op))), GetRef<Expr>(op));
   }
 
   PStatic VisitExpr_(const ConstructorNode* op, LetList* ll) final {
@@ -702,8 +810,94 @@ class PartialEvaluator : public ExprFunctor<PStatic(const Expr& e, LetList* ll)>
     }
   }
 
- private:
+  void InitializeFuncId(const Expr& e) {
+    struct InitializeFuncIdVisitor : ExprVisitor, PatternVisitor {
+      PartialEvaluator* pe;
+      explicit InitializeFuncIdVisitor(PartialEvaluator* pe) : pe(pe) { }
+
+      void VisitExpr_(const FunctionNode* op) final {
+        Function f = GetRef<Function>(op);
+        CHECK_EQ(pe->func_map_.count(f), 0);
+        pe->func_map_.insert({f, pe->func_map_.size()});
+        VisitExpr(f->body);
+      }
+
+      void VisitPattern(const Pattern& p) final {
+        PatternVisitor::VisitPattern(p);
+      }
+    };
+    InitializeFuncIdVisitor(this).VisitExpr(e);
+  }
+
+  Expr RegisterFuncId(const Expr& e) {
+    struct RegisterFuncIdVisitor : ExprVisitor, PatternVisitor {
+      PartialEvaluator* pe;
+      explicit RegisterFuncIdVisitor(PartialEvaluator* pe) : pe(pe) { }
+
+      void VisitExpr_(const AnnotateNode* op) final {
+        if (const WithFuncIdNode* n = op->annotation.as<WithFuncIdNode>()) {
+          Function f = AsFunc(op->expr);
+          if (pe->func_map_.count(f) != 0) {
+            CHECK_EQ(pe->func_map_.at(f), n->fid);
+          }
+          pe->func_map_.insert({f, n->fid});
+        }
+        ExprVisitor::VisitExpr_(op);
+      }
+
+      void VisitExpr_(const FunctionNode* op) final {
+        Function f = GetRef<Function>(op);
+        CHECK_GT(pe->func_map_.count(f), 0);
+        ExprVisitor::VisitExpr_(op);
+      }
+
+      void VisitPattern(const Pattern& p) final {
+        PatternVisitor::VisitPattern(p);
+      }
+    };
+    RegisterFuncIdVisitor(this).VisitExpr(e);
+    return e;
+  }
+
+  Expr AnnotateFuncId(const Expr& e) {
+    struct AnnotateFuncIdMutator : ExprMutator, PatternMutator {
+      PartialEvaluator* pe;
+      explicit AnnotateFuncIdMutator(PartialEvaluator* pe) : pe(pe) { }
+
+      Expr VisitExpr_(const FunctionNode* op) final {
+        Function f = GetRef<Function>(op);
+        CHECK_GT(pe->func_map_.count(f), 0);
+        return MkWithFuncId(ExprMutator::VisitExpr_(op), pe->func_map_.at(f));
+      }
+
+      Pattern VisitPattern(const Pattern& p) final {
+        return PatternMutator::VisitPattern(p);
+      }
+
+      Var VisitVar(const Var& v) final {
+        return v;
+      }
+    };
+    return AnnotateFuncIdMutator(this).VisitExpr(e);
+  }
+
+private:
   Environment env_;
+  Module mod_;
+  std::unordered_map<GlobalVar, PStatic, NodeHash, NodeEqual> gv_map_;
+  /*! Termination checking is done as follow:
+   *  We have finitely many FunctionId.
+   *  Each Function Id map to a class of semantically equivalent function (ignoring type),
+   *  as both TypeSubst, DeDup create semantically equivalent function.
+   *  We partially map each FunctionId to a std::vector<Time>,
+   *  denoting the minimal TimeFrame of the arguments of the function.
+   *  Every time we try to inline a Function, we make sure it either not has a vector<Time>,
+   *  or some argument has lesser time.
+   *  In any case, we remap the mapping to a minimal vector<Time>
+   *  when we PE inside the Function body.
+   */
+  std::unordered_map<Function, FuncId, NodeHash, NodeEqual> func_map_;
+  std::unordered_map<FuncId, std::vector<Time> > time_map_;
   Store store_;
   DLContext context_ = CPUContext();
   FInterpreter executor_ = CPUInterpreter();
@@ -719,14 +913,22 @@ TypeVar DeDupTypeVar(const TypeVar& tv) {
 
 /*! \brief Use a fresh Id for every Var to make the result well-formed. */
 Expr DeDup(const Expr& e) {
-  class DeDupMutator : public ExprMutator, public PatternMutator {
+  class DeDupMutator : public ExprMutator,
+                       public PatternMutator,
+                       public TypeMutator {
    public:
     Var Fresh(const Var& v) {
-      Var ret = DeDupVar(v);
+      Var ret = VarNode::make(v->name_hint(), VisitType(v->type_annotation));
       rename_[v] = ret;
       return ret;
     }
 
+    TypeVar Fresh(const TypeVar& v) {
+      TypeVar ret = DeDupTypeVar(v);
+      type_rename_[v] = ret;
+      return ret;
+    }
+
     Expr VisitExpr(const Expr& e) final {
       return ExprMutator::VisitExpr(e);
     }
@@ -737,18 +939,27 @@ Expr DeDup(const Expr& e) {
     }
 
     Expr VisitExpr_(const LetNode* op) final {
-      return LetNode::make(Fresh(op->var), VisitExpr(op->value), VisitExpr(op->body));
+      Var v = Fresh(op->var);
+      return LetNode::make(v, VisitExpr(op->value), VisitExpr(op->body));
+    }
+
+    Type VisitType(const Type& t) final {
+      return t.defined() ? TypeMutator::VisitType(t) : t;
     }
 
     Expr VisitExpr_(const FunctionNode* op) final {
+      tvm::Array<TypeVar> type_params;
+      for (const TypeVar& type_param : op->type_params) {
+        type_params.push_back(Fresh(type_param));
+      }
       tvm::Array<Var> params;
       for (const Var& param : op->params) {
         params.push_back(Fresh(param));
       }
       return FunctionNode::make(params,
                                 VisitExpr(op->body),
-                                op->ret_type,
-                                op->type_params,
+                                VisitType(op->ret_type),
+                                type_params,
                                 op->attrs);
     }
 
@@ -756,14 +967,28 @@ Expr DeDup(const Expr& e) {
       return PatternMutator::VisitPattern(p);
     }
 
+    Clause VisitClause(const Clause& c) final {
+      Pattern pat = VisitPattern(c->lhs);
+      return ClauseNode::make(pat, VisitExpr(c->rhs));
+    }
+
     Var VisitVar(const Var& v) final {
       return Fresh(v);
     }
 
+    Type VisitType_(const TypeVarNode* op) final {
+      TypeVar v = GetRef<TypeVar>(op);
+      return type_rename_.count(v) != 0 ? type_rename_.at(v) : v;
+    }
+
    private:
     std::unordered_map<Var, Var, NodeHash, NodeEqual> rename_;
+    std::unordered_map<TypeVar, TypeVar, NodeHash, NodeEqual> type_rename_;
   };
-  return DeDupMutator().VisitExpr(e);
+
+  Expr ret = DeDupMutator().VisitExpr(e);
+  CHECK_EQ(FreeVars(ret).size(), FreeVars(e).size());
+  return ret;
 }
 
 /*! \brief Remap multiple Var sharing the same Id into the same Var. */
@@ -787,18 +1012,45 @@ Expr Remap(const Expr& e) {
   return RemapMutator().VisitExpr(e);
 }
 
-Expr PartialEval(const Expr& e) {
+Expr StripWithFuncId(const Expr& e) {
+  struct StripWithFuncIdMutator : ExprMutator, PatternMutator {
+    Expr VisitExpr_(const AnnotateNode* op) final {
+      if (op->annotation.as<WithFuncIdNode>()) {
+        return VisitExpr(op->expr);
+      } else {
+        return ExprMutator::VisitExpr(GetRef<Expr>(op));
+      }
+    }
+
+    Pattern VisitPattern(const Pattern& p) final {
+      return PatternMutator::VisitPattern(p);
+    }
+
+    Var VisitVar(const Var& v) final {
+      return v;
+    }
+
+  };
+  return StripWithFuncIdMutator().VisitExpr(e);
+}
+
+Expr PostProcess(const Expr& e) {
+  return StripWithFuncId(DeDup(Remap(e)));
+}
+
+Expr PartialEval(const Expr& e, const Module& m) {
   return TransformF([&](const Expr& e) {
       return LetList::With([&](LetList* ll) {
-          PartialEvaluator pe(FreeVars(e));
-          return Remap(DeDup(pe.VisitExpr(e, ll)->dynamic));
+          PartialEvaluator pe(FreeVars(e), m);
+          pe.InitializeFuncId(e);
+          return PostProcess(pe.VisitExpr(pe.RegisterFuncId(pe.AnnotateFuncId(e)), ll)->dynamic);
         });
     }, e);
 }
 
-TVM_REGISTER_API("relay._ir_pass.partial_evaluate")
+TVM_REGISTER_API("relay._ir_pass.partial_eval")
 .set_body([](TVMArgs args, TVMRetValue* ret) {
-    *ret = PartialEval(args[0]);
+    *ret = PartialEval(args[0], args[1]);
   });
 
 }  // namespace relay
diff --git a/src/relay/pass/to_a_normal_form.cc b/src/relay/pass/to_a_normal_form.cc
index bac6fd28faf58..b5fd957c30217 100644
--- a/src/relay/pass/to_a_normal_form.cc
+++ b/src/relay/pass/to_a_normal_form.cc
@@ -216,7 +216,9 @@ DependencyGraph DependencyGraph::Create(common::Arena* arena, const Expr& body)
   return Creator(arena).Create(body);
 }
 
-Expr ToANormalForm(const Expr& e, const Module& m, std::set<GlobalVar>* gv);
+Expr ToANormalForm(const Expr& e,
+                   const Module& m,
+                   std::unordered_set<GlobalVar, NodeHash, NodeEqual>* gv);
 
 struct ScopeNode;
 using Scope = std::shared_ptr<ScopeNode>;
@@ -286,7 +288,7 @@ class Fill : ExprFunctor<Expr(const Expr&, const Var&)> {
                             const Module& m,
                             const DependencyGraph& dg,
                             std::unordered_map<DependencyGraph::Node*, Scope>* node_scope,
-                            std::set<GlobalVar>* gv) {
+                            std::unordered_set<GlobalVar, NodeHash, NodeEqual>* gv) {
     Fill fi(m, dg, node_scope, gv);
     return fi.GetScope(e)->ll->Get(fi.VisitExpr(e));
   }
@@ -295,13 +297,13 @@ class Fill : ExprFunctor<Expr(const Expr&, const Var&)> {
   Module mod_;
   const DependencyGraph& dg_;
   std::unordered_map<DependencyGraph::Node*, Scope>* node_scope_;
-  std::set<GlobalVar>* visited_;
+  std::unordered_set<GlobalVar, NodeHash, NodeEqual>* visited_;
   std::unordered_map<Expr, Expr, NodeHash, NodeEqual> memo;
 
   Fill(Module mod,
        const DependencyGraph& dg,
        std::unordered_map<DependencyGraph::Node*, Scope>* node_scope,
-       std::set<GlobalVar>* visited) :
+       std::unordered_set<GlobalVar, NodeHash, NodeEqual>* visited) :
     mod_(mod),
     dg_(dg),
     node_scope_(node_scope),
@@ -455,7 +457,9 @@ class Fill : ExprFunctor<Expr(const Expr&, const Var&)> {
   }
 };
 
-Expr ToANormalFormAux(const Expr& e, const Module& m, std::set<GlobalVar>* gv) {
+Expr ToANormalFormAux(const Expr& e,
+                      const Module& m,
+                      std::unordered_set<GlobalVar, NodeHash, NodeEqual>* gv) {
   /* When you lift a lambda, what is inside is also being lift.
    *
    * So we must determine the scope of the lambda before determining the scope of it's body.
@@ -481,12 +485,14 @@ Expr ToANormalFormAux(const Expr& e, const Module& m, std::set<GlobalVar>* gv) {
   return Fill::ToANormalForm(e, m, dg, &node_scope, gv);
 }
 
-Expr ToANormalForm(const Expr& e, const Module& m, std::set<GlobalVar>* gv) {
+Expr ToANormalForm(const Expr& e,
+                   const Module& m,
+                   std::unordered_set<GlobalVar, NodeHash, NodeEqual>* gv) {
   return TransformF([&](const Expr& e) { return ToANormalFormAux(e, m, gv); }, e);
 }
 
 Expr ToANormalForm(const Expr& e, const Module& m) {
-  std::set<GlobalVar> gv;
+  std::unordered_set<GlobalVar, NodeHash, NodeEqual> gv;
   return ToANormalForm(e, m, &gv);
 }
 
diff --git a/tests/python/relay/test_pass_dead_code_elimination.py b/tests/python/relay/test_pass_dead_code_elimination.py
index 963d490eaf50b..c6444af007527 100644
--- a/tests/python/relay/test_pass_dead_code_elimination.py
+++ b/tests/python/relay/test_pass_dead_code_elimination.py
@@ -93,12 +93,20 @@ def test_op_let():
 
 
 def test_tuple_get_item():
-    t = relay.Var('t')
+    t = relay.Var("t")
     g = relay.TupleGetItem(t, 0)
     assert alpha_equal(dead_code_elimination(g), g)
     assert alpha_equal(dead_code_elimination(relay.TupleGetItem(relay.Let(e.a, e.one, t), 0)), g)
 
 
+def test_dce_respect_effect():
+    r = relay.Var("r")
+    u = relay.Var("u")
+    orig = relay.Let(u, relay.RefWrite(r, relay.const(1)), relay.RefRead(r))
+    print(dead_code_elimination(orig))
+    assert alpha_equal(dead_code_elimination(orig), orig)
+
+
 if __name__ == "__main__":
     test_let()
     test_used_let()
@@ -107,3 +115,4 @@ def test_tuple_get_item():
     test_recursion()
     test_op_let()
     test_tuple_get_item()
+    test_dce_respect_effect()
diff --git a/tests/python/relay/test_pass_partial_eval.py b/tests/python/relay/test_pass_partial_eval.py
index a00cebd244b37..1e4fd1dcfc2eb 100644
--- a/tests/python/relay/test_pass_partial_eval.py
+++ b/tests/python/relay/test_pass_partial_eval.py
@@ -1,13 +1,14 @@
 import numpy as np
 import tvm
 from tvm import relay
-from tvm.relay.ir_pass import partial_evaluate, dead_code_elimination
-from tvm.relay.ir_pass import gradient, alpha_equal, infer_type
+from tvm.relay.ir_pass import partial_eval, alpha_equal, infer_type, dead_code_elimination, gradient
 from tvm.relay import op, create_executor
 from tvm.relay.backend.interpreter import Value, TupleValue, ConstructorValue
 from tvm.relay.prelude import Prelude
 from tvm.relay import create_executor
-
+from tvm.relay import Var, TypeVar, TupleGetItem, Let, Function, const, RefRead, RefWrite, RefCreate
+from tvm.relay import TensorType, Tuple, If, Module, Clause, PatternConstructor, PatternVar, Match
+from tvm.relay import GlobalVar, Call, Type
 
 def check_eval(expr, expected_result, mod=None, rtol=1e-07):
     ctx = tvm.context("llvm", 0)
@@ -17,23 +18,23 @@ def check_eval(expr, expected_result, mod=None, rtol=1e-07):
     np.testing.assert_allclose(result.asnumpy(), expected_result, rtol=rtol)
 
 
-def dcpe(expr):
-    return dead_code_elimination(partial_evaluate(expr))
+def dcpe(expr, mod=None):
+    return dead_code_elimination(partial_eval(expr, mod=mod))
 
 
 def test_tuple():
-    t = relay.TypeVar("t")
-    x = relay.Var("x", t)
-    body = relay.TupleGetItem(relay.Tuple([relay.const(4.0), x]), 1)
-    f = relay.Function([x], body, None, [t])
+    t = TypeVar("t")
+    x = Var("x", t)
+    body = TupleGetItem(relay.Tuple([relay.const(4.0), x]), 1)
+    f = Function([x], body, None, [t])
     assert alpha_equal(dcpe(f), relay.Function([x], x, None, [t]))
 
 
 def test_const_inline():
-    d = relay.Var("d")
-    double = relay.Function([d], d + d)
-    orig = double(relay.const(4.0))
-    assert alpha_equal(dcpe(double(relay.const(4.0))), relay.const(8.0))
+    d = Var("d")
+    double = Function([d], d + d)
+    orig = double(const(4.0))
+    assert alpha_equal(dcpe(orig), const(8.0))
 
 
 def test_ref():
@@ -41,43 +42,67 @@ def test_ref():
     r = relay.Var("r")
     x = relay.Var("x")
     body = relay.RefRead(r)
-    body = relay.Let(x, relay.RefWrite(r, relay.RefRead(r) * relay.RefRead(r)), body)
-    body = relay.Let(r, relay.RefCreate(d), body)
-    square = relay.Function([d], body)
-    assert alpha_equal(dcpe(square), relay.Function([d], d * d))
+    body = Let(x, RefWrite(r, RefRead(r) * RefRead(r)), body)
+    body = Let(r, RefCreate(d), body)
+    square = Function([d], body)
+    assert alpha_equal(dcpe(square), Function([d], d * d))
+
+
+def test_empty_ad():
+    shape = (10, 10)
+    dtype = "float32"
+    t = TensorType(shape, dtype)
+    d = Var("d", t)
+    f = Function([d], d)
+    g = dcpe(gradient(f))
+    m = d * d
+    x = relay.Var("x")
+    o = op.ones_like(x)
+    x1 = relay.Var("x1")
+    grad = op.zeros_like(d) + op.collapse_sum_like(x1 * d, d) + op.collapse_sum_like(x1 * d, d)
+    body = Tuple([x, Tuple([grad])])
+    body = relay.Let(x1, o, body)
+    expected = Function([d], relay.Let(x, m, body))
+    print(g)
+    assert alpha_equal(g, expected)
 
 
 def test_ad():
     shape = (10, 10)
     dtype = "float32"
-    t = relay.TensorType(shape, dtype)
-    d = relay.Var("d", t)
-    f = relay.Function([d], d * d)
+    t = TensorType(shape, dtype)
+    d = Var("d", t)
+    f = Function([d], d * d)
     g = dcpe(gradient(f))
     m = d * d
-    o = relay.op.ones_like(m)
-    grad = relay.op.zeros_like(d) + relay.op.collapse_sum_like(o * d, d) + relay.op.collapse_sum_like(o * d, d)
-    expected = relay.Function([d], relay.Tuple([m, relay.Tuple([grad])]))
+    x = relay.Var("x")
+    o = op.ones_like(x)
+    x1 = relay.Var("x1")
+    grad = op.zeros_like(d) + op.collapse_sum_like(x1 * d, d) + op.collapse_sum_like(x1 * d, d)
+    body = Tuple([x, Tuple([grad])])
+    body = relay.Let(x1, o, body)
+    expected = Function([d], relay.Let(x, m, body))
+    print(g)
     assert alpha_equal(g, expected)
 
 
 def test_if_ref():
     shape = ()
     dtype = "bool"
-    t = relay.TensorType(shape, dtype)
-    d = relay.Var("d", t)
-    r = relay.Var("r")
-    update = relay.Function([], relay.RefWrite(r, relay.RefRead(r) + relay.RefRead(r)))
-    u = relay.Var("u")
-    body = relay.If(d, u(), u())
-    eff = relay.Var("eff")
-    body = relay.Let(eff, body, relay.RefRead(r))
-    f = relay.Function([d], relay.Let(r, relay.RefCreate(relay.const(1)), relay.Let(u, update, body)))
+    t = TensorType(shape, dtype)
+    d = Var("d", t)
+    r = Var("r")
+    update = Function([], RefWrite(r, RefRead(r) + RefRead(r)))
+    u = Var("u")
+    body = If(d, u(), u())
+    eff = Var("eff")
+    body = Let(eff, body, RefRead(r))
+    f = Function([d], Let(r, RefCreate(const(1)), Let(u, update, body)))
     f = infer_type(f)
-    pe_f = infer_type(partial_evaluate(f))
+    pe_f = infer_type(partial_eval(f))
     ex = create_executor()
-    f_res = ex.evaluate(f)(relay.const(True))
-    pe_f_res = ex.evaluate(pe_f)(relay.const(True))
+    f_res = ex.evaluate(f)(const(True))
+    pe_f_res = ex.evaluate(pe_f)(const(True))
     np.testing.assert_allclose(f_res.asnumpy(), 2 * np.ones_like(f_res.asnumpy()))
     np.testing.assert_allclose(pe_f_res.asnumpy(), 2 * np.ones_like(pe_f_res.asnumpy()))
 
@@ -85,52 +110,74 @@ def test_if_ref():
 def test_function_invalidate():
     shape = ()
     dtype = "bool"
-    t = relay.TensorType(shape, dtype)
-    d = relay.Var("d", t)
-    r = relay.Var("r")
-    fetch = relay.Function([], relay.RefRead(r))
-    fet = relay.Var("fetch")
-    fet_obscured = relay.Var("fetch_obscured")
-    u = relay.Var("u")
-    body = relay.If(d, fet_obscured(), fet_obscured())
-    body = relay.Let(u, relay.RefWrite(r, relay.const(1)), body)
-    body = relay.Let(fet_obscured, relay.If(d, fet, fet), body)
-    body = relay.Let(fet, fetch, body)
-    body = relay.Let(r, relay.RefCreate(relay.const(0)), body)
-    f = relay.Function([d], body)
+    t = TensorType(shape, dtype)
+    d = Var("d", t)
+    r = Var("r")
+    fetch = Function([], RefRead(r))
+    fet = Var("fetch")
+    fet_obscured = Var("fetch_obscured")
+    u = Var("u")
+    body = If(d, fet_obscured(), fet_obscured())
+    body = Let(u, RefWrite(r, const(1)), body)
+    body = Let(fet_obscured, If(d, fet, fet), body)
+    body = Let(fet, fetch, body)
+    body = Let(r, RefCreate(const(0)), body)
+    f = Function([d], body)
     f = infer_type(f)
-    pe_f = infer_type(partial_evaluate(f))
+    pe_f = infer_type(partial_eval(f))
     ex = create_executor()
-    f_res = ex.evaluate(f)(relay.const(True))
-    pe_f_res = ex.evaluate(pe_f)(relay.const(True))
+    f_res = ex.evaluate(f)(const(True))
+    pe_f_res = ex.evaluate(pe_f)(const(True))
     np.testing.assert_allclose(f_res.asnumpy(), np.ones_like(f_res.asnumpy()))
     np.testing.assert_allclose(pe_f_res.asnumpy(), np.ones_like(pe_f_res.asnumpy()))
 
 
 def test_head_cons():
-    mod = relay.Module()
+    mod = Module()
     p = Prelude(mod)
     def hd_impl():
-        a = relay.TypeVar("a")
-        x = relay.Var("x", p.l(a))
-        y = relay.Var("y")
-        z = relay.Var("z")
-        cons_case = relay.Clause(relay.PatternConstructor(p.cons,
-                                                          [relay.PatternVar(y),
-                                                           relay.PatternVar(z)]),
-                                 y)
-        return relay.Function([x], relay.Match(x, [cons_case]), a, [a])
-    t = relay.TypeVar("t")
-    x = relay.Var("x", t)
-    hd = relay.Var("hd")
-    body = relay.Let(hd, hd_impl(), hd(p.cons(x, p.nil())))
-    f = relay.Function([x], body, None, [t])
+        a = TypeVar("a")
+        x = Var("x", p.l(a))
+        y = Var("y")
+        z = Var("z")
+        cons_case = Clause(PatternConstructor(p.cons,
+                                              [PatternVar(y),
+                                               PatternVar(z)]),
+                           y)
+        return Function([x], Match(x, [cons_case]), a, [a])
+    t = TypeVar("t")
+    x = Var("x", t)
+    hd = Var("hd")
+    body = Let(hd, hd_impl(), hd(p.cons(x, p.nil())))
+    f = Function([x], body, None, [t])
     f = infer_type(f, mod=mod)
     res = dcpe(f)
-    assert alpha_equal(res, relay.Function([x], x, t, [t]))
+    assert alpha_equal(res, Function([x], x, t, [t]))
+
+
+def test_map():
+    mod = Module()
+    p = Prelude(mod)
+    f = Var("f")
+    orig = p.map(f, p.cons(const(1), p.cons(const(2), p.cons(const(3), p.nil()))))
+    expected = p.cons(f(const(1)), p.cons(f(const(2)), p.cons(f(const(3)), p.nil())))
+    assert alpha_equal(dcpe(orig, mod=mod), expected)
+
+
+def test_loop():
+    mod = Module()
+    t = TypeVar("t")
+    x = Var("x", t)
+    loop = GlobalVar("loop")
+    mod[loop] = Function([x], loop(x), t, [t])
+    res = dcpe(loop(const(1)), mod=mod)
+    expected = Call(loop, [const(1)], None, [None])
+    assert alpha_equal(res, expected)
 
 
 if __name__ == '__main__':
+    test_empty_ad()
+    raise
     test_tuple()
     test_const_inline()
     test_ref()
@@ -138,3 +185,5 @@ def hd_impl():
     test_if_ref()
     test_function_invalidate()
     test_head_cons()
+    test_map()
+    test_loop()