Tie::Simple(3)

✨ NAME ✨ — Tie::Simple(3) 💖

Tie::Simple — variable ties made easier: much, much, much easier... 🫶

🎀 VERSION 🎀

version 1.04 — that's the one, bestie. ✨

🌸 SYNOPSIS 🌸

Ok so here's the whole “look how easy this is” lineup. You use Tie::Simple;, then you tie whatever variable type you want and hand over your name/CODE pairs:

use Tie::Simple;

tie $scalar, 'Tie::Simple', $data,
    FETCH     => sub { ... },
    STORE     => sub { ... };

tie @array, 'Tie::Simple', $data,
    FETCH     => sub { ... },
    STORE     => sub { ... },
    FETCHSIZE => sub { ... },
    STORESIZE => sub { ... },
    EXTEND    => sub { ... },
    EXISTS    => sub { ... },
    DELETE    => sub { ... },
    CLEAR     => sub { ... },
    PUSH      => sub { ... },
    POP       => sub { ... },
    SHIFT     => sub { ... },
    UNSHIFT   => sub { ... },
    SPLICE    => sub { ... };

tie %hash, 'Tie::Simple', $data,
    FETCH     => sub { ... },
    STORE     => sub { ... },
    DELETE    => sub { ... },
    CLEAR     => sub { ... },
    EXISTS    => sub { ... },
    FIRSTKEY  => sub { ... },
    NEXTKEY   => sub { ... };

tie *HANDLE, 'Tie::Simple', $data,
    WRITE     => sub { ... },
    PRINT     => sub { ... },
    PRINTF    => sub { ... },
    READ      => sub { ... },
    READLINE  => sub { ... },
    GETC      => sub { ... },
    CLOSE     => sub { ... };

💅 DESCRIPTION 💅

This module adds the ability to quickly create new types of tie objects without creating a complete class. It does that in a way that tries to make the programmer’s life easier when it comes to single-use ties that the author finds themself wanting to use from time to time. 🫶

The Tie::Simple package is actually a front-end to other classes that really do all the work once tied, but this package does the dwimming to automatically figure out what you’re trying to do. ✨

The author tried to make this as intuitive as possible and dependent on other bits of Perl where possible, to minimize the need for documentation and make this extra, extra spiffy. 💖

🦋 SIMPLE TYING 🦋

To set up your quick tie, simply start with the typical tie statement on the variable you’re tying. You should always tie to the Tie::Simple package and not directly to the other packages included with this module, because those are only present as helpers — even though they are really the tie classes. 👑

The type of tie depends upon the type of the first argument given to tie. This should be rather obvious from the SYNOPSIS above. Therefore, the arguments are:

1. The variable to be tied.
2. The string 'Tie::Simple'.
3. A scalar value (hereafter called the “local data”).
4. A list of name/CODE pairs.

At this point, you’ll need to have some understanding of tying before you can continue. The author suggests looking through perltie. 📚

As you will note in the perltie documentation, every tie package defines functions whose first argument is called this. The third argument, local data, will take the place of this in all the subroutine calls you define in the name/CODE pair list. Each name should be the name of the function that would be defined for the appropriate tie-type if you were to do a full-blown package definition. The subroutine matched to that name will take the exact arguments specified in the perltie documentation, but instead of this it will be given the local data scalar value you set — which could even be undef if you don’t need it. 🎀

🔥 TIES CAN BE SIMPLER STILL 🔥

The synopsis above shows the typical subroutines you could define. The author left out the UNTIE and DESTROY methods, but you may define these if you need them — just be sure to read the perltie documentation on possible caveats. 👀

⚠️ Caveat corner, bestie: UNTIE and DESTROY are allowed, but the perltie docs have the possible-caveats tea. Read before you ship it. ☕

However, the SYNOPSIS is way more complete than you probably need to be in most cases. This is because Tie::Simple does its best to make use of some of the handy Perl built-ins that help with creating tie packages. ✨

🍓 SCALARS 🍓

If you are creating a scalar tie, then you can assume all the benefits of being a Tie::Scalar. 💖

🍇 ARRAYS 🍇

If you are creating an array tie, then you may assume all the benefits of being a Tie::Array. 🦋

🍓 HASHES 🍓

If you are creating a hash tie, then you may assume all the benefits of being a Tie::Hash. 🌸

🎀 HANDLES 🎀

If you are creating a handle tie, then you may assume all the benefits of being a Tie::Handle. 💅

💀 TO DO 💀

ngl, it sure would be nice if you could declare custom @ISA lists, wouldn’t it? The author would like to add such a feature, but coming up with some custom SUPER:: dispatch code or generating new anonymous packages are the only ways they can think to do it. They don’t really have time to add such a feature just now. 😭

🌈 SEE ALSO 🌈

• perltie
• Tie::Scalar
• Tie::Array
• Tie::Hash
• Tie::Handle

👑 AUTHOR 👑

Andrew Sterling Hanenkamp <hanenkamp@cpan.org> 💌

🎀 COPYRIGHT AND LICENSE 🎀

This software is copyright (c) 2015 by Qubling Software LLC.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

---

That’s a wrap, bestie — this page is tied to perl v5.42.0, dated 2015-11-29, and filed under Tie::Simple(3). 💅✨