Lingua::Awkwords - randomly generates outputs from a given pattern


  use feature qw(say);
  use Lingua::Awkwords;
  use Lingua::Awkwords::Subpattern;

  # V is a pre-defined subpattern, ^ filters out aa from the list
  # of two vowels that the two VV generate
  my $la = Lingua::Awkwords->new( pattern => q{ [VV]^aa } );

  say $la->render for 1..10;

  # define our own C, V
      C => [qw/j k l m n p s t w/],
      V => [qw/a e i o u/],
  # and a pattern somewhat suitable for Toki Pona...

  say $la->render for 1..10;


This is a Perl implementation of

though is not an exact replica of that parser;

details the format that this code is based on. Briefly,


[] or ()

Denote a unit or group; they are identical except that (a) is equivalent to [a/]--that is, it represents the possibility of generating the empty string in addition to any other terms supplied.

Units can be nested recursively. There is an implicit unit at the top level of the pattern.


Introduces a choice within a unit; without this [Vx] would generate whatever V represents (a list of vowels by default) followed by the letter x while [V/x] by contrast generates only a vowel or the letter x.


The asterisk followed by an integer in the range 1..128 inclusive weights the current term of the alternation, if any. That is, while [a/] generates each term with equal probability, [a/*2] would generate the empty string at twice the probability of the letter a.


The caret introduces a filter that must follow a unit (there is an implicit unit at the top level of a pattern). An example would be [VV]^aa or the equivalent VV^aa that (by default) generates two vowels, but replaces aa with the empty string. More than one filter may be specified.


Capital ASCII letters denote subpatterns; several of these are set by default. See Lingua::Awkwords::Subpattern for how to customize them. V for example is by default equivalent to the more verbose [a/i/u].


Use double quotes to denote a quoted string; this prevents other characters (besides " itself) from being interpreted as some non- string value.


Anything else not otherwise accounted for above is treated as part of a string, so ["abc"/abc] generates either the string abc or the string abc, as this is two ways of saying the same thing.



Awkword pattern. Without this supplied any call to render will throw an exception.


Where the parse tree is stored.



Constructor. Typically this should be passed a pattern argument.

parse_string pattern

Returns the parse tree of the given pattern without setting the tree attribute. "COMPLICATIONS" shows one use for this.


Returns a string render of the awkword pattern. This may be the empty string if filters have removed all the text.

walk callback

Provides a means to recurse through the parse tree, where every object in the tree will call the callback with $self as the sole argument, and then if necessary iterate through all of the possibilities contained by itself calling walk on each of those.


More complicated structures can be built by attaching parse trees to subpatterns. For example, Toki Pona could be extended to allow optional diphthongs (mostly in the second syllable) via

  use feature qw(say);
  use Lingua::Awkwords::Subpattern;
  use Lingua::Awkwords;
  my $cv  = Lingua::Awkwords->parse_string(q{
  my $cvv = Lingua::Awkwords->parse_string(q{

      A => $cv,
      B => $cvv,
      C => [qw/j k l m n p s t w/],
      V => [qw/a e i o u/],

  my $tree = Lingua::Awkwords->new( pattern => q{
      [ a[B/BA/BAA/A/AA/AAA] / [AB/ABA/ABAA/A/AA/AAA] ] [n/*5]

  say join ' ', map { $tree->render } 1 .. 10;

The default filter of the empty string can be problematical, as one may not know whether a filter has been applied to the result, or the word may be filtered into an incorrect form. The above trees with filters can be modified as follows

  $tree->walk( set_filter('X') );

  # more or less the equivalent of a let-over-lambda in LISP
  sub set_filter {
      my $filter = shift;
      return sub {
          my $self = shift;
          $self->filter_with($filter) if $self->can('filter_with');

to instead replace filtered values with X and then enough words generated minus those filtered via

  my @words;
  while (1) {
      my $possible = $tree->render;
      next if $possible =~ m/X/;
      push @words, $possible;
      last if @words >= 10;
  say join ' ', @words;


Reporting Bugs

Please report any bugs or feature requests to bug-lingua-awkwords at, or through the web interface at

Patches might best be applied towards:

Known Issues

There are various incompatibilities with the original version of the code; these are detailed in the parser module as they concern how e.g. weights are parsed.

See also the "Known Issues" section in all the other modules in this distribution.


Lingua::Awkwords::ListOf, Lingua::Awkwords::OneOf, Lingua::Awkwords::Parser, Lingua::Awkwords::String, Lingua::Awkwords::Subpattern


thrig - Jeremy Mates (cpan:JMATES) <jmates at>


Copyright (C) 2017 by Jeremy Mates

This program is distributed under the (Revised) BSD License: