# Create a new clone of this matrix
	redef fun clone
	do
		var c = new Matrix(width, height)
		for i in [0..width*height[ do c.items[i] = items[i]
		return c
	end

	redef fun clone: SELF
	do
		# By default the clone abort to avoid surprises
		print "The clone method is not implemented for the `{self.class_name}` class"
		abort
	end

	# Shallow clone of the tree.
	#
	# ~~~
	# var t = new OrderedTree[Int]
	# t.add_all(null, [1, 2])
	# t.add_all(1, [11, 12])
	#
	# assert t.clone == t
	# ~~~
	redef fun clone
	do
		var res = new OrderedTree[E]
		res.add_all(null, roots)
		for p, es in sub do
			res.add_all(p, es)
		end
		return res
	end

	redef fun clone: SELF
	do
		var clone_n_qualified = n_qualified
		if n_qualified != null then clone_n_qualified = n_qualified.clone
		return new AQid.init_aqid(clone_n_qualified, n_id.clone)
	end

	redef fun clone: SELF
	do
		return new AQclassid.init_aqclassid(n_qualified.clone, n_id)
	end

	redef fun clone: SELF
	do
		var ntype = n_type
		if ntype != null then ntype = n_type.clone
		return new ASignature.init_asignature(null, n_params.clone, null, ntype)
	end

	redef fun clone: SELF
	do
		var ntype = n_type
		if ntype != null then ntype = n_type.clone
		return new AParam.make(variable, ntype)
	end

	redef fun clone: SELF
	do
		return new AType.make(mtype)
	end

	redef fun clone: SELF
	do
		return new AQualified.init_aqualified(n_id.clone, n_classid)
	end

	redef fun clone: SELF
	do
		return new TId.init_tk(location)
	end

	redef fun clone do return sub(self)

	redef fun clone: SELF
	do
		var clone = new ABlockExpr.make(mtype)
		for expr in self.n_expr do
			clone.add(expr.clone)
		end
		return clone
	end

	redef fun clone: SELF
	do
		return new ASelfExpr.make(self.variable, self.mtype)
	end

	redef fun clone: SELF
	do
		return new AIntegerExpr.make(value, mtype)
	end

	redef fun clone: SELF
	do
		return new AFloatExpr.make(value, mtype)
	end

	redef fun clone do return union(self)

	# Shallow clone of `self`
	#
	# ~~~
	# var a = new ArrayMap[String,Int]
	# a["one"] = 1
	# a["two"] = 2
	# var b = a.clone
	# assert a == b
	# a["zero"] = 0
	# assert a != b
	# ~~~
	#
	# Note that the clone is shallow and keys and values are shared between `self` and the result.
	#
	# ~~~
	# var aa = new ArrayMap[String, Array[Int]]
	# aa["two"] = [1,2]
	# var bb = aa.clone
	# assert aa == bb
	# aa["two"].add 5
	# assert aa == bb
	# ~~~
	redef fun clone
	do
		var res = new ArrayMap[K,E]
		res.add_all self
		return res
	end

	# Shallow copy
	#
	#     var s = new DisjointSet[Int]
	#     s.add_all([1,2,3,4,5])
	#     s.union_all([1,4,5])
	#     var s2 = s.clone
	#     assert s2.number_of_subsets == 3
	#     assert s2.all_in_same_subset([1,4,5]) == true
	#     assert s2.in_same_subset(1,2) == false
	redef fun clone do return new DisjointSet[E].from(self)

	redef fun clone: SELF
	do
		var self_clone = new AImplicitSelfExpr.make(variable, mtype)
		self_clone.is_sys = is_sys
		return self_clone
	end

	redef fun clone: SELF
	do
		var self_clone = new ACharExpr.make(self.value, mtype, n_char.text)
		return self_clone
	end

	redef fun clone: SELF
	do
		return new ATrueExpr.make(mtype)
	end

	redef fun clone: SELF
	do
		return new AFalseExpr.make(mtype)
	end

	# Shallow clone of `self`
	#
	# ~~~
	# var a = new ArraySet[Int]
	# a.add 1
	# a.add 2
	# var b = a.clone
	# assert a == b
	# a.add 3
	# assert a != b
	# b.add 3
	# assert a == b
	# ~~~
	#
	# Note that the clone is shallow and keys and values are shared between `self` and the result.
	#
	# ~~~
	# var aa = new ArraySet[Array[Int]]
	# aa.add([1,2])
	# var bb = aa.clone
	# assert aa == bb
	# aa.first.add 5
	# assert aa == bb
	# ~~~
	redef fun clone
	do
		var res = new ArraySet[E]
		res.add_all self
		return res
	end

	redef fun clone: SELF
	do
		var clone_anodes = new ANodes[E](self.parent)
		for node in self do
			clone_anodes.add(node.clone)
		end
		return clone_anodes
	end

	# Not a deep copy.
	redef fun clone do return new FlowHashMap[K, V].from(self)

	# ~~~
	# var b = new Buffer
	# b.append("Buffer!")
	# var c = b.clone
	# assert b == c
	# ~~~
	redef fun clone do
		var cln = new Buffer.with_cap(byte_length)
		cln.append self
		return cln
	end

	# Shallow clone of `self`
	#
	# ~~~
	# var a = [1,2,3]
	# var b = a.clone
	# assert a == b
	# a.add 4
	# assert a != b
	# b.add 4
	# assert a == b
	# ~~~
	#
	# Note that the clone is shallow and elements are shared between `self` and the result.
	#
	# ~~~
	# var aa = [a]
	# var bb = aa.clone
	# assert aa == bb
	# aa.first.add 5
	# assert aa == bb
	# ~~~
	redef fun clone do return to_a

	redef fun clone do return new FlowHashSet[E].from(self)

	redef fun clone do return self