Rename FnValue into Closure (apache#33)

relay/include/tvm/relay/ir/value.h

@@ -90,28 +90,28 @@ class FloatValueNode : public ValueNode {
 
 RELAY_DEFINE_VALUE(FloatValue, FloatValueNode);
 
-class FnValue;
+class Closure;
 
 /*! \brief A floating point value. */
-class FnValueNode : public ValueNode {
+class ClosureNode : public ValueNode {
  public:
  tvm::Map<LocalId, Value> env;
  Function func;
 
- FnValueNode() {}
+ ClosureNode() {}
 
  void VisitAttrs(tvm::AttrVisitor* v) final {
  v->Visit("env", &env);
  v->Visit("func", &func);
  }
 
- TVM_DLL static FnValue make(tvm::Map<LocalId, Value> env, Function func);
+ TVM_DLL static Closure make(tvm::Map<LocalId, Value> env, Function func);
 
- static constexpr const char* _type_key = "relay.FnValue";
- TVM_DECLARE_NODE_TYPE_INFO(FnValueNode, ValueNode);
+ static constexpr const char* _type_key = "relay.Closure";
+ TVM_DECLARE_NODE_TYPE_INFO(ClosureNode, ValueNode);
 };
 
-RELAY_DEFINE_VALUE(FnValue, FnValueNode);
+RELAY_DEFINE_VALUE(Closure, ClosureNode);
 
 class ProductValue;
 

relay/python/relay/ir/__init__.py

@@ -63,7 +63,7 @@
 IntValue = value.IntValue
 FloatValue = value.FloatValue
 BoolValue = value.BoolValue
-FnValue = value.FnValue
+Closure = value.Closure
 TensorValue = value.TensorValue
 
 # Type

relay/python/relay/ir/value.py

@@ -47,7 +47,7 @@ class BoolValue(Value):
 
 
 @register_relay_node
-class FnValue(Value):
+class Closure(Value):
  env: Dict[LocalId, Value]
  func: Function
 

relay/src/tvm/relay/evaluator.cc

@@ -135,7 +135,7 @@ struct Evaluator : ExprFunctor<Value(const Expr& n)> {
  return this->stack.lookup(local);
  }
 
- Value invoke(const FnValue& func, tvm::Array<Value>& args);
+ Value invoke(const Closure& func, tvm::Array<Value>& args);
  Value invoke_intrinsic(const IntrinsicId& op, tvm::Array<Value>& args,
  const tvm::Array<Type>& arg_types);
  Value Eval(const Expr& expr);
@@ -264,7 +264,7 @@ Value Evaluator::VisitExpr_(const FunctionNode* op) {
  for (const auto& id : free_id) {
  free_var_values.Set(id, Eval(id));
  }
- return FnValueNode::make(free_var_values, GetRef<Function>(op));
+ return ClosureNode::make(free_var_values, GetRef<Function>(op));
 }
 
 Value Evaluator::invoke_intrinsic(const IntrinsicId& op,
@@ -335,7 +335,7 @@ Value Evaluator::invoke_intrinsic(const IntrinsicId& op,
 
 // An efficient interpreter needs a faster way to access args, relative to stack
 // pointer?
-Value Evaluator::invoke(const FnValue& closure, tvm::Array<Value>& args) {
+Value Evaluator::invoke(const Closure& closure, tvm::Array<Value>& args) {
  // In the VM we should support building a frame from free vars and parameters
  // we should compute the frame layout statically.
 
@@ -401,8 +401,8 @@ Value Evaluator::VisitExpr_(const CallNode* op) {
  return this->invoke_intrinsic(GetRef<IntrinsicId>(intr), args, op->ty_args);
  } else {
  auto fn_val = this->VisitExpr(op->fn);
- if (const FnValueNode* closure = fn_val.as<FnValueNode>()) {
- return this->invoke(GetRef<FnValue>(closure), args);
+ if (const ClosureNode* closure = fn_val.as<ClosureNode>()) {
+ return this->invoke(GetRef<Closure>(closure), args);
  } else {
  throw EvalError(
  "Type error, expected function value in the call position");
@@ -567,8 +567,8 @@ TVM_REGISTER_API("relay.eval.invoke")
  // type check the call before execution.
  Evaluator eval(env);
  auto fn_val = eval.VisitExpr(id);
- if (const FnValueNode* closure = fn_val.as<FnValueNode>()) {
- *ret = eval.invoke(GetRef<FnValue>(closure), relay_args);
+ if (const ClosureNode* closure = fn_val.as<ClosureNode>()) {
+ *ret = eval.invoke(GetRef<Closure>(closure), relay_args);
  } else {
  throw EvalError(
  "Type error, expected function value in the call position");

relay/src/tvm/relay/ir/value.cc

@@ -63,21 +63,21 @@ TVM_STATIC_IR_FUNCTOR_REGISTER(IRPrinter, vtable)
  p->stream << "FloatValueNode(" << node->value << ")";
  });
 
-FnValue FnValueNode::make(tvm::Map<LocalId, Value> env, Function func) {
- std::shared_ptr<FnValueNode> n = std::make_shared<FnValueNode>();
+Closure ClosureNode::make(tvm::Map<LocalId, Value> env, Function func) {
+ std::shared_ptr<ClosureNode> n = std::make_shared<ClosureNode>();
  n->env = std::move(env);
  n->func = std::move(func);
- return FnValue(n);
+ return Closure(n);
 }
 
-TVM_REGISTER_API("relay.make.FnValue")
+TVM_REGISTER_API("relay.make.Closure")
  .set_body([](TVMArgs args, TVMRetValue *ret) {
- *ret = FnValueNode::make(args[0], args[1]);
+ *ret = ClosureNode::make(args[0], args[1]);
  });
 
 TVM_STATIC_IR_FUNCTOR_REGISTER(IRPrinter, vtable)
- .set_dispatch<FnValueNode>([](const FnValueNode *node, tvm::IRPrinter *p) {
- p->stream << "FnValueNode(todo)";
+ .set_dispatch<ClosureNode>([](const ClosureNode *node, tvm::IRPrinter *p) {
+ p->stream << "ClosureNode(todo)";
  });
 
 ProductValue ProductValueNode::make(tvm::Array<Value> value) {

relay/tests/python/test_ast.py

@@ -207,10 +207,10 @@ def test_float_value():
  assert fv.value == 1.135
 
 
-def test_fn_value():
+def test_closure():
  params = [Param(LocalId("x"), IntType(2))]
  fn = Function(params, IntType(2), LocalId("x"))
- fn_val = FnValue({}, fn)
+ fn_val = Closure({}, fn)
  assert fn_val.func == fn