A function-based API can be (almost) automatically generated from methods -- all you need is a customized import sub. A default object is created during import and each package using the module has a private default object. This approach usually works a bit better than Flexx's because (1) it avoids creating lots of temporary objects, and (2) there's a long-lived object around to hold module state, so all the state-setting methods still work.

I wouldn't recommend the CGI.pm module for studying this technique. CGI.pm is difficult to understand because of its long and glorious history. Take a look at my code below, read the docs on packages and symbolic references, look at Exporter.pm and then you're ready to crack open CGI.pm. 

## MyClass.pm

package MyClass;
use strict;

my @export = qw(verbose isFile);

sub new {
    my ($class, %args) = @_;
    my $self = {verbose => $args{verbose} || 0};
    return bless $self, $class;
}

sub verbose {
    my $self = shift;
    $self->{verbose} = shift if @_;
    return $self->{verbose};
}

sub isFile {
    my ($self, $file) = @_;
    my $found = -f $file;
    if ($self->verbose) {
        print STDERR "$file ", ($found ? 'found' : 'not found'), "\n";
    }
    return $found;
}

sub import {
    my $module = shift;
    my $mode = shift || ':methods';

    if ($mode eq ':functions') {
        no strict 'refs';

        my ($package) = caller();
        my $object = MyClass->new(@_);

        foreach my $name (@export) {
            my $sub = $MyClass::{$name};

            *{$package.'::'.$name} = sub {
                &{$sub}($object, @_)
            };
        }
    }
}

1;

## test.pl

package verbose_main;
use strict;
use MyClass (':functions', verbose => 1);

sub test {
    if (isFile('MyClass.pm')) {
        print "ok\n";
    }
    if (verbose()) {
        print "verbose mode on\n";
    }
}

package quiet_main;
use strict;
use MyClass (':functions');

sub test {
    if (isFile('MyClass.pm')) {
        print "ok\n";
    }
    verbose(1);
    if (isFile('NotFound')) {
        print "ok\n";
    }
}

package oo_main;
use strict;
use MyClass;

my $env = MyClass->new(verbose => 1);

sub test {
    if ($env->isFile('MyClass.pm')) {
        print "ok\n";
    }
}

package main;
use strict;

verbose_main::test();
quiet_main::test();
oo_main::test();

[download]

In reply to Custom import for alternate module APIs by blssu
in thread How to morph a plain module to OO by Rudif

Title:
Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post, it's "PerlMonks-approved HTML":


  • Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
  • Titles consisting of a single word are discouraged, and in most cases are disallowed outright.
  • Read Where should I post X? if you're not absolutely sure you're posting in the right place.
  • Please read these before you post! —
  • Posts may use any of the Perl Monks Approved HTML tags:
    a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
  • You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)
            For:     Use:
    & &amp;
    < &lt;
    > &gt;
    [ &#91;
    ] &#93;
  • Link using PerlMonks shortcuts! What shortcuts can I use for linking?
  • See Writeup Formatting Tips and other pages linked from there for more info.