Implement classmethod() and staticmethod()

ncw · ncw · commit 6bd194a8744c · 2013-12-07T14:46:07.000Z
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -65,10 +65,10 @@ func init() {
 		"bool":     py.BoolType,
 		// "memoryview":     py.MemoryViewType,
 		// "bytearray":      py.ByteArrayType,
-		"bytes": py.BytesType,
-		// "classmethod":    py.ClassMethodType,
-		"complex": py.ComplexType,
-		"dict":    py.StringDictType, // FIXME
+		"bytes":       py.BytesType,
+		"classmethod": py.ClassMethodType,
+		"complex":     py.ComplexType,
+		"dict":        py.StringDictType, // FIXME
 		// "enumerate":      py.EnumType,
 		// "filter":         py.FilterType,
 		"float":     py.FloatType,
@@ -82,8 +82,8 @@ func init() {
 		// "reversed":       py.ReversedType,
 		"set": py.SetType,
 		// "slice":          py.SliceType,
-		// "staticmethod":   py.StaticMethodType,
-		"str": py.StringType,
+		"staticmethod": py.StaticMethodType,
+		"str":          py.StringType,
 		// "super":          py.SuperType,
 		"tuple": py.TupleType,
 		"type":  py.TypeType,
diff --git a/py/classmethod.go b/py/classmethod.go
@@ -0,0 +1,67 @@
+// ClassMethod objects
+
+package py
+
+var ClassMethodType = ObjectType.NewType("classmethod",
+	`classmethod(function) -> method
+
+Convert a function to be a class method.
+
+A class method receives the class as implicit first argument,
+just like an instance method receives the instance.
+To declare a class method, use this idiom:
+
+  class C:
+      def f(cls, arg1, arg2, ...): ...
+      f = classmethod(f)
+
+It can be called either on the class (e.g. C.f()) or on an instance
+(e.g. C().f()).  The instance is ignored except for its class.
+If a class method is called for a derived class, the derived class
+object is passed as the implied first argument.
+
+Class methods are different than C++ or Java static methods.
+If you want those, see the staticmethod builtin.`, ClassMethodNew, nil)
+
+type ClassMethod struct {
+	Callable Object
+	Dict     StringDict
+}
+
+// Type of this ClassMethod object
+func (o ClassMethod) Type() *Type {
+	return ClassMethodType
+}
+
+// Get the Dict
+func (c *ClassMethod) GetDict() StringDict {
+	return c.Dict
+}
+
+// ClassMethodNew
+func ClassMethodNew(metatype *Type, args Tuple, kwargs StringDict) (res Object) {
+	c := &ClassMethod{}
+	UnpackTuple(args, kwargs, "classmethod", 1, 1, &c.Callable)
+	return c
+}
+
+// Read a classmethod from a class which makes a bound method
+func (c *ClassMethod) M__get__(instance, owner Object) Object {
+	if owner == nil {
+		owner = instance.Type()
+	}
+	return NewBoundMethod(owner, c.Callable)
+}
+
+// Properties
+func init() {
+	ClassMethodType.Dict["__func__"] = &Property{
+		Fget: func(self Object) Object {
+			return self.(*ClassMethod).Callable
+		},
+	}
+}
+
+// Check interface is satisfied
+var _ IGetDict = (*ClassMethod)(nil)
+var _ I__get__ = (*ClassMethod)(nil)
diff --git a/py/staticmethod.go b/py/staticmethod.go
@@ -0,0 +1,61 @@
+// StaticMethod objects
+
+package py
+
+var StaticMethodType = ObjectType.NewType("staticmethod",
+	`staticmethod(function) -> method
+
+Convert a function to be a static method.
+
+A static method does not receive an implicit first argument.
+To declare a static method, use this idiom:
+
+     class C:
+     def f(arg1, arg2, ...): ...
+     f = staticmethod(f)
+
+It can be called either on the class (e.g. C.f()) or on an instance
+(e.g. C().f()).  The instance is ignored except for its class.
+
+Static methods in Python are similar to those found in Java or C++.
+For a more advanced concept, see the classmethod builtin.`, StaticMethodNew, nil)
+
+type StaticMethod struct {
+	Callable Object
+	Dict     StringDict
+}
+
+// Type of this StaticMethod object
+func (o StaticMethod) Type() *Type {
+	return StaticMethodType
+}
+
+// Get the Dict
+func (c *StaticMethod) GetDict() StringDict {
+	return c.Dict
+}
+
+// StaticMethodNew
+func StaticMethodNew(metatype *Type, args Tuple, kwargs StringDict) (res Object) {
+	c := &StaticMethod{}
+	UnpackTuple(args, kwargs, "staticmethod", 1, 1, &c.Callable)
+	return c
+}
+
+// Read a staticmethod from a class - no bound method here
+func (c *StaticMethod) M__get__(instance, owner Object) Object {
+	return c.Callable
+}
+
+// Properties
+func init() {
+	StaticMethodType.Dict["__func__"] = &Property{
+		Fget: func(self Object) Object {
+			return self.(*StaticMethod).Callable
+		},
+	}
+}
+
+// Check interface is satisfied
+var _ IGetDict = (*StaticMethod)(nil)
+var _ I__get__ = (*StaticMethod)(nil)
