+ Magic is Perl's way of enhancing variables. This mechanism lets the user
+ add extra data to any variable and hook syntactical operations (such as
+ access, assignment or destruction) that can be applied to it. With this
+ module, you can add your own magic to any variable without having to
+ write a single line of XS.
+
+ You'll realize that these magic variables look a lot like tied
+ variables. It is not surprising, as tied variables are implemented as a
+ special kind of magic, just like any 'irregular' Perl variable : scalars
+ like $!, $( or $^W, the %ENV and %SIG hashes, the @ISA array, "vec()"
+ and "substr()" lvalues, threads::shared variables... They all share the
+ same underlying C API, and this module gives you direct access to it.
+
+ Still, the magic made available by this module differs from tieing and
+ overloading in several ways :
+
+ * Magic is not copied on assignment.
+
+ You attach it to variables, not values (as for blessed references).
+
+ * Magic does not replace the original semantics.
+
+ Magic callbacks usually get triggered before the original action
+ takes place, and cannot prevent it from happening. This also makes
+ catching individual events easier than with "tie", where you have to
+ provide fallbacks methods for all actions by usually inheriting from
+ the correct "Tie::Std*" class and overriding individual methods in
+ your own class.
+
+ * Magic is multivalued.
+
+ You can safely apply different kinds of magics to the same variable,
+ and each of them will be invoked successively.
+
+ * Magic is type-agnostic.
+
+ The same magic can be applied on scalars, arrays, hashes, subs or
+ globs. But the same hook (see below for a list) may trigger
+ differently depending on the type of the variable.
+
+ * Magic is invisible at Perl level.
+
+ Magical and non-magical variables cannot be distinguished with
+ "ref", "tied" or another trick.
+
+ * Magic is notably faster.
+
+ Mainly because perl's way of handling magic is lighter by nature,
+ and because there is no need for any method resolution. Also, since
+ you don't have to reimplement all the variable semantics, you only
+ pay for what you actually use.