bless | SSH Certificate Authority that runs as a AWS Lambda function | Identity Management library

Since there are 7 days, you can divide the count by 7

I've never used blessed before, so I'll give you a partial solution.

First of all, you should to know there's various examples in their repo that you can use to learn more about this package. Here is one: https://github.com/jquast/blessed/blob/master/bin/worms.py

So, after mentioning that, I leave you with a code example that might help. I put some comments on it because I think they can be useful.

You are passing three arguments to new plus the invocant. The last is a reference to an array. That means that @skills ends up with a single element whose value is that reference.

The problem is that you call

You can monkey-patch methods onto a class, but it’s done like this:

The error comes from using a hash ref where you should have an array ref:

If there is an ambiguous type variable v with a Num v constraint, it gets defaulted to Integer or Double, tried in that order, whichever satisfies all other constraints on v.

Those defaulting rules are explained in the Haskell Report: https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-620004

The GHC manual also explains additional defaulting rules in GHCi (this means trying things in GHCi will not give you an accurate picture of what is going on when you compile a program): https://downloads.haskell.org/ghc/latest/docs/html/users_guide/ghci.html#type-defaulting-in-ghci

[Note: I'm am a former maintainer of Exporter]

I believe you've confused exporting with inheritance. That's easy to do, Perl doesn't draw a line between "function" and "method", they're just sub.

tl;dr You don't need to export, that's just how inheritance works, there is a work around.

Exporting lets you call a function from outside of a package without fully qualifying it. It would let you call Foo::hello as just hello. Exporting lets Perl know that hello really means hello in package Foo.

But these are method calls, and you call them on a class or object. my $foo = Foo->new; $foo->hello. No exporting required. Foo->new calls new in Foo and returns a Foo object. $foo->hello knows to look for the method foo in the ancestry of $foo's class. You don't need to use exporter in a class, that's what "Do not export method names" means.

Exporting is a deliberate act which copies symbols around. Inheritance is all or nothing. If you inherit from a class you get all its methods (subs). This is a consequence of inheritance, and there are many other alternatives to inheritance such as composition.

In other OO languages you could declare the method private and it would not be inherited. Perl doesn't have that. Normally you just live with this by convention as you have, put an underscore in front of the method name, don't document it, and if somebody uses it that's their problem. And that's usually fine.

But you can make truly private methods with anonymous subs and lexical variables.

It's a choice to make for yourself.

If you're writing a library, you really ought to report failure to the caller, which may be able to recover in ways you can't internally, and which might need to perform other cleanup that's not done by registered atexit() handlers.

If your code might be called from C++ or other high-level languages, then again, don't unilaterally exit, as that prevents destructors running to perform similar cleanup.

When you check memory use using Valgrind, then exit() will leave lots of objects in the "still accessible" state, making it harder to find your real leaks.

So I generally recommend returning from main(), but would tolerate some use of exit() in program-specific code that's never going to end up in a library.