Implements the Common Lisp (format) function.


In Lisp, C<~&> only adds a newline if there wasn't a newline on STDOUT
previously.


SPEC_DIFFERENCES

NAME

my $fl = Format::Lisp.new;
    say $fl.format( "~~,,'~c:~c", ',', 'X' );
    my $func = $fl.formatter( "x~ax" );


SYNOPSIS

DESCRIPTION

Given a format string and the appropriate (if any) args, return the formatted
output


METHODS


use Format::Lisp::Grammar;
use Format::Lisp::Actions;

my role Debugging {
}

my role Testing {
}

my role Validating {
}

class Format::Lisp {
	also does Debugging;
	also does Testing;
	also does Validating;

	has $.grammar = Format::Lisp::Grammar.new;
	has $.actions = Format::Lisp::Actions.new;

	method _match( Str $source ) {
		my $parsed = $.grammar.parse( $source );
		$parsed;
	}

	method _parse( Str $source ) {
		my $parsed = $.grammar.parse(
			$source,
			:actions( $.actions )
		);

		$parsed.ast;
	}

	multi method accumulate(
		Format::Lisp::Directive::Angle $directive,
		$index, @arguments
	) {
		return self._format(
			@( $directive.children ),
			@( @arguments[$index] )
		);
	}
	multi method accumulate(
		Format::Lisp::Directive::Brace $directive,
		$index, @arguments
	) {
		if $directive.colon {
			if $directive.trailing-colon {
				return join( '', map {
					self._format(
						@( $directive.children ),
						@( $_ )
					)
				}, @( @arguments[$index] ) );
			}
			elsif $directive.at {
			}
			elsif $directive.n {
				my $n = $directive.n;
				my $formatted;
				for 1 .. +$n min @( @arguments[$index] ).elems -> $x {
					$formatted ~= self._format(
						@( $directive.children ),
						@( @arguments[$index][$x-1] )
					);
				}
				return $formatted;
			}
			else {
				return join( '', map {
					self._format(
						@( $directive.children ),
						@( $_ )
					)
				}, @( @arguments[$index] ) );
			}
		}
		elsif $directive.trailing-colon {
			if $directive.at {
			}
			elsif $directive.n {
			}
			else {
			}

			return join( '', map {
				self._format(
					@( $directive.children ),
					@( $_ )
				)
			}, @( @arguments[$index] ) );
		}
		elsif $directive.at {
			if $directive.n {
			}
			else {
			}
		}
		elsif $directive.n {
			if +$directive.n > 0 {
				if @arguments[$index] {
				}
				else {
					return '';
				}
				return '';
			}
			elsif +$directive.n == 0 {
				if @arguments[$index] {
					return join( '', map {
						self._format(
							@( $directive.children ),
							@( $_ )
						)
					}, @( @arguments[$index] ) );
				}
			}
		}
		elsif @arguments[$index] and @arguments[$index] ~~ Sub {
			return join( '', map {
				@arguments[$index]( $_ )
			}, @( @arguments[$index+1] ) );
		}
		else {
			if @arguments[$index] {
				return join( '', map {
					self._format(
						@( $directive.children ),
						@( $_ )
					)
				}, @( @arguments[$index] ) );
			}
		}
		return '';
	}
	multi method accumulate(
		Format::Lisp::Directive::Bracket $directive,
		$index, @arguments
	) {
		my $formatted = self._format( # XXX Could cause issues
			@( $directive.children ),
			@( @arguments[$index] )
		);
		return $directive.postprocess( $formatted, $index, @arguments );
	}
	multi method accumulate(
		Format::Lisp::Directive::Paren $directive,
		$index,
		@arguments
	) {
		my $formatted = self._format(
			@( $directive.children ),
			@( @arguments[$index] )
		);
		return $directive.postprocess( $formatted, $index, @arguments );
	}
	multi method accumulate( $directive, $index, @arguments ) {
		return $directive.to-string(
			@arguments[$index],
			@arguments[$index+1],
			@arguments.elems - $index
		);
	}

	method _format( @directives, @arguments ) {
		my $index = 0;
		return join( '', map {
			my $text = self.accumulate(
				$_, $index, @arguments
			);
			my $offset = $_.to-offset(
				$index,
				@arguments[$index],
				@arguments[$index+1],
				@arguments.elems
			);
			$index += $offset;
			$text;
		}, @directives );
	}

	method format( Str $format, **@arguments ) {
		return '' unless $format;
		my @directives = self._parse( $format );
		my $text = self._format( @directives, @arguments );
		return $text;
	}

	method formatter( Str $format ) {
		my $fl = self;
		return sub ( *@args ) {
			return $fl.format( $format, |@args );
		}
	}
}


root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

Format::Lisp - Common Lisp formatter


Format::Lisp::Actions - Actions for Common Lisp format strings


Image

head

code

item

README

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Format::Lisp - Common Lisp formatter

NAME

SYNOPSIS

METHODS

Format::Lisp v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation