Perl6::Bible::S29(3) User Contributed Perl Documentation Perl6::Bible::S29(3)NAME
Synopsis_29 - Functions
AUTHOR
Rod Adams <rod@rodadams.net>
VERSION
Maintainer: Larry Wall <larry@wall.org>
Date: 12 Mar 2005
Last Modified: 23 Feb 2006
Version: 1
This document attempts to document the list of builtin functions in
Perl 6. It assumes familiarity with Perl 5 and prior synopses.
The document is now the official S29. It's still here in the pugs
repository temporarily to allow easy access to pugs implementors, but
eventually it will be copied over to svn.perl.org. -law
Notes
In Perl 6, all builtin functions belong to a named package. Not all
functions are guaranteed to be imported into the global package "::*".
In addition, the list of functions imported into "::*" will be subject
to change with each release of Perl. Authors wishing to "Future Proof"
their code should either specifically import the functions they will be
using, or always refer to the functions by their full name.
After 6.0.0 comes out, global aliases will not be removed lightly, and
will never be removed at all without having gone through a deprecation
cycle of at least a year. In any event, you can specify that you want
the interface for a particular version of Perl, and that can be
emulated by later versions of Perl to the extent that security updates
allow.
Where code is given here, it is intended to define semantics, not to
dictate implementation.
Type Declarations
The following type declarations are assumed:
AnyChar
The root class of all "character" types, regardless of level.
This is a subtype of "Str", limited to a length of 1 at it's
highest supported Unicode level.
The type name "Char" is aliased to the maximum supported Unicode
level in the current lexical scope (where "current" is taken to
mean the eventual lexical scope for generic code (roles and
macros), not the scope in which the generic code is defined). In
other words, use "Char" when you don't care which level you're
writing for.
Subclasses (things that are "isa AnyChar"):
LinguaChar or Ling (language-defined characters)
GraphemeChar or Graf (language-independent graphemes)
CodePoint or Uni (Unicode codepoints)
Byte
Yes, Byte is both a string and a number.
MatchTest
subset MatchTest of Item | Junction;
Used to supply a test to match against. Assume "~~" will be used
against it.
Function Packages
Math::Basic
abs
our Num multi Num::abs ( Num $x )
our Num multi Math::Basic::abs ( Num $x = $+_ )
Absolute Value.
floor
our Int multi Num::floor ( Num $x )
Returns the highest integer not greater than $x.
ceiling
our Int multi Num::ceiling ( Num $x )
&Num::ceil ::= &Num::ceiling;
Returns the lowest integer not less than $x.
round
our Int multi Num::round ( Num $x )
our Int multi Int ( Num $x )
Returns the nearest integer to $x. The algorithm is floor($x +
0.5). (Other rounding algorithms will be given extended names
beginning with "round".)
truncate
our Int multi Num::truncate ( Num $x )
our &Num::int ::= &Num::truncate;
Returns the closest integer to $x whose absolute value is not
greater than the absolute value of $x. (In other words, just chuck
any fractional part.) This is the default rounding function used
by an "int()" cast, for historic reasons. But see Int constructor
above for a rounded version.
exp
our Num multi Num::exp ( Num $exponent: Num :$base = Num::e )
our Num multi Math::Basic::exp ( Num $exponent = $+_, Num :$base = Num::e )
Performs similar to "$base ** $exponent". $base defaults to the
constant e.
log
our Num multi Num::log ( Num $x: Num :$base )
our Num multi Math::Basic::log ( Num $x = $+_, Num :$base )
Logarithm of base $base, default Natural. Calling with "$x == 0" is
an error.
log10
&log10 := &log.assuming:base(10);
rand
our Num multi Math::Basic::rand ( Num $x = 1 )
Pseudo random number in range "0 ..^ $x". That is, 0 is
theoretically possible, while $x is not.
sign
our Int multi Num::sign ( Num $x )
our Int multi Math::Basic::sign ( Num $x = $+_ )
if !defined($x) { return undef };
if $x < 0 { return -1 };
if $x > 0 { return 1 };
if $x == 0 { return 0 };
undef;
}
or more succinctly:
our Int multi Math::Basic::sign ( Num $x = $+_ )
$x <=> 0;
}
srand
multi Math::Basic::srand ( Num $seed = default_seed_algorithm())
Seed the generator "rand" uses. $seed defaults to some combination
of various platform dependent characteristics to yield a non-
deterministic seed. Note that you get one "srand()" for free when
you start a Perl program, so you must call "srand()" yourself if
you wish to specify a deterministic seed (or if you wish to be
differently nondeterministic).
sqrt
our Num multi Num::sqrt ( Num $x )
our Complex multi Complex::sqrt ( Num $x )
our Complex multi Complex::sqrt ( Complex $x )
our Num multi Math::Basic::sqrt ( Num $x = $+_ )
"$x ** 0.5"
e
constant Num Num::e = exp(1);
pi
constant Num Num::pi = atan(1,1) * 4;
constant Int Int::pi = 3;
i
constant Complex Complex::i = Complex::sqrt(-1);
one
constant Int Int::one = round(-e ** (-i * pi)); # :-)
Math::Trig
Standard Trig Functions
our Num multi Num::func ( Num $x : :$base = 'radians' )
our Num multi Math::Trig::func ( Num $x = $+_, :$base = 'radians' )
where func is one of: sin, cos, tan, asin, acos, atan, sec, cosec,
cotan, asec, acosec, acotan, sinh, cosh, tanh, asinh, acosh, atanh,
sech, cosech, cotanh, asech, acosech, acotanh.
Performs the various trigonmetric functions.
Option ":$base" is used to declare how you measure your angles.
Given the value of an arc representing a single full revolution.
$base Result
-----------
/:i ^r/ Radians (2*pi)
/:i ^d/ Degrees (360)
/:i ^g/ Gradians (400)
Num Units of 1 revolution.
Note that module currying can be used within a lexical scope to
specify a consistent base so you don't have to supply it with every
call:
my module Trig ::= Math::Trig.assuming(:base<degrees>);
This overrides the default of "radians".
atan
our Num multi Math::Trig::atan2 ( Num $y, Num $x = 1 : Num :$base )
This second form of "atan" computes the arctangent of $y/$x, and
takes the quadrant into account. Otherwise behaves as other
trigonometric functions.
[Note: changed atan back to atan2, or the default $x = 1 will
confuse MMD. The other alternative would be to remove the default.
--law]
Array
delete
our List multi method Array::delete (@array : *@indices )
Sets elements specified by @indices in the invocant to a non-
existent state, as if they never had a value. Deleted elements at
the end of an Array shorten the length of the Array, unless doing
so would violate an "is shape()" definition.
@indices is interpreted the same way as subscripting is in terms of
slices and multidimensionality. See Synopsis 9 for details.
Returns the value(s) previously held in deleted locations.
An unary form is expected. See "Hash::delete".
exists
our Bool multi method Array::exists (@array : Int *@indices )
True if the specified Array element has been assigned to. This is
not the same as being defined.
Supplying a different number of indices than invocant has
dimensions is an error.
An unary form is expected. See "Hash::delete".
pop
&Array::pop := &Array::splice.assuming(:offset(-1) :length(1));
our Scalar multi Array::pop ( )
Array::pop @+_;
}
push
our Int multi Array::push ( @array is rw : *@values )
Array::splice(@array, @array.elems, 0, @values);
@array.elems;
}
shift
&Array::shift := &Array::splice.assuming(:offset(0) :length(1));
our Scalar multi Array::shift ( )
Array::shift @+_;
}
splice
multi List Array::splice ( @array is rw
: Int $offset = 0,
Int $length,
*@values ) is rw
Behaves similar as Perl 5 "splice".
If @array is multidimensional, "splice" operates only on the first
dimension, and works with Array References.
unshift
our Int multi Array::unshift ( @array is rw : *@values )
Array::splice(@array, 0, 0, @values);
@array.elems;
}
keys
kv
pairs
values
multi Int|List Array::keys ( @array : MatchTest *@indextests )
multi Int|List Array::kv ( @array : MatchTest *@indextests )
multi Int|(List of Pair) Array::pairs (@array : MatchTest *@indextests )
multi Int|List Array::values ( @array : MatchTest *@indextests )
(XXX these signatures are wrong. -luqui)
Iterates the elements of @array, in order.
If @indextests are provided, only elements whose indices match
"$index ~~ any(@indextests)" are iterated.
What is returned at each element of the iteration varies with
function. "values" returns the value of the associated element;
"kv" returns a 2 element list in (index, value) order, "pairs" a
"Pair(index, value)".
@array is considered single dimensional. If it is in fact multi-
dimensional, the values returned will be array references to the
sub array.
In Scalar context, they all return the count of elements that would
have been iterated.
List
grep
our Lazy multi Array::grep ( @values : Code *&test )
our Lazy multi Array::grep ( @values : MatchTest $test )
our Lazy multi List::grep ( MatchTest $test : *@values )
gather {
for @values -> $x {
take $x if $x ~~ $test;
}
}
}
join
our Str multi Array::join ( @values : Str $delimiter )
our Str multi List::join ( Str $delimiter : *@values )
my $str = ~@values[0];
for 1..@values.end {
$str ~= $delimiter ~ @values[$_];
}
$str;
}
&join := &join.assuming:delimiter(' ');
map
our Lazy multi Array::map ( @values : Code *&expression )
our Lazy multi List::map ( Code $expression : *@values )
gather {
while @values {
take $expression
.( splice(@values, 0, $expression.arity) );
}
}
}
reduce
our Scalar multi Array::reduce ( @values : Code *&expression )
our Scalar multi List::reduce ( Code $expression : *@values )
my $res;
for @values -> $cur {
FIRST {$res = $cur; next;}
$res = &$expression($res, $cur);
}
$res;
}
reverse
our Hash multi Hash::reverse ( %hash )
(my %result){%hash.values} = %hash.keys;
%result;
}
multi Lazy|Str Array::reverse ( @values )
multi Lazy|Str List::reverse ( *@values )
given want {
when List {
gather {
1 while take pop @values;
}
}
when Scalar {
reverse @values ==> join;
}
}
}
sort
subset KeyExtractor of Code(Any --> Any);
subset Comparator of Code(Any, Any --> Int );
subset SortCriterion of KeyExtractor | Comparator | Pair(KeyExtractor, Comparator);
our Array multi Array::sort( @values is rw, *&by: Bit :$inplace )
our Array multi Array::sort( @values is rw, SortCriterion @by: Bit :$inplace )
our Array multi Array::sort( @values is rw: SortCriterion :$by = &infix:<cmp>, Bit :$inplace )
our List multi List::sort( SortCriterion @by: *@values )
our List multi List::sort( SortCriterion $by = &infix:<cmp>, *@values )
Returns @values sorted, using criteria $by or @by for comparisons.
@by differs from $by in that each criteria is applied, in order,
until a non-zero (tie) result is achieved.
Criterion can take a few different forms:
Comparator
A closure with arity of 2, which returns
negative/zero/positive, signaling the first arguement
should be before/tied with/after the second in the final
ordering of the List. aka "The Perl 5 way"
KeyExtractor
A closure with arity of 1, which returns the "key" by which
to sort. If the closure returns a Num, "<=>" is used for
comparison, otherwise "cmp".
Pair(KeyExtractor, Comparator)
A combination of the two methods above, for when one wishs
to take advantage of the internal caching of keys that is
expected to happen, but wishes to compare them with
something other than "<=>" or "cmp".
Any Criterion may recieve either or both of the traits "is
descending" and "is insensitive" to reverse the order of sort, or
the adjust the case sensitivity of "cmp" as a Comparator.
If all criteria are exhausted when comparing two elements, sort
should return them in the same relative order they had in @values.
If $inplace is specified, the array is sorted in place.
See <http://www.nntp.perl.org/group/perl.perl6.language/16578> for
more details and examples.
zip
our Lazy multi List::zip ( Array *@lists, Bit :$shortest ) {
gather {
while $shortest ?? all(@lists) !! any(@lists) {
for @lists -> @list {
take shift @list;
}
}
}
}
[Note: This should be the definition of each() now. The zip
function needs to build tuples of the "across" values. Also, it
maybe probably be in terms of longest non-infinite. -law]
Hash
delete
our List multi method Hash::delete ( *@keys )
our Scalar multi method Hash::delete ( $key ) is default
Deletes the elements specified by $key or $keys from the invocant.
returns the value(s) that were associated to those keys.
Unary Form
Implementations should create a suitable macro, or otherwise
support the unary form "delete %hash{$key}" in all its forms.
Below are some example translations. This list is not
exhaustive.
delete %hash{$key} %hash.delete{$key}
delete %hash<key> %hash.delete{'key'}
delete %hash<key1>{@keys} %hash<key1>.delete{@keys}
exists
our Bool multi method Hash::exists ( $key )
True if invocant has an element whose key matches $key, false
otherwise.
A unary form is expected. See Hash::delete.
See also Code::exists to determine if a function has been declared.
(Use defined() to determine whether the function body is defined.
A body of ... counts as undefined.)
keys
kv
pairs
values
multi Int|List Hash::keys ( %hash : MatchTest *@keytests )
multi Int|List Hash::kv ( %hash : MatchTest *@keytests )
multi Int|(List of Pair) Hash::pairs (%hash : MatchTest *@keytests )
multi Int|List Hash::values ( %hash : MatchTest *@keytests )
Iterates the elements of %hash in no apparent order, but the order
will be the same between successive calls to these functions, as
long as %hash doesn't change.
If @keytests are provided, only elements whose keys evaluate "$key
~~ any(@keytests)" as true are iterated.
What is returned at each element of the iteration varies with
function. "keys" only returns the key; "values" the value; "kv"
returns both as a 2 element list in (key, value) order, "pairs" a
"Pair(key, value)".
Note that "kv %hash" returns the same as "zip(keys %hash; values
%hash)"
In Scalar context, they all return the count of elements that would
have been iterated.
The lvalue form of "keys" is not longer supported. Use the
".buckets" property instead.
Str
General notes about strings:
A Str can exist at several Unicode levels at once. Which level you
interact with typically depends on what your current lexical context
has declared the "working unicode level to be". Default is GChar.
[Q: Default can't be LChar because we don't go into "language" mode
unless there's a specific language declaration saying either exactly
what language we're going into, or what environmental parameter to pay
attention to to select our language. So I believe the default should
be GChar. -law]
Attempting to use a string at a level higher it can support is handled
without warning. The current highest supported level of the string is
simply mapped Char for Char to the new higher level. However,
attempting to stuff something of a higher level a lower-level string is
an error (for example, attempting to store Kanji in a Byte string).
And explicit conversion function must be used to tell it how you want
it encoded.
Attempting to use a string at a level lower than what it supports is
not allowed.
If a function takes a "Str" and returns a "Str", the returned "Str"
will support the same levels as the input, unless specified otherwise.
P5chop
our Char multi P5emul::Str::P5chop ( Str $string is rw )
our Char multi P5emul::Str::P5chop ( Str *@strings = ($+_) is rw )
Trims the last character from $string, and returns it. Called with
a list, it chops each item in turn, and returns the last character
chopped.
chop
our Str method Str::chop ( Str $string: )
Returns string with one Char removed from the end.
P5chomp
our Int multi P5emul::Str::P5chomp ( Str $string is rw )
our Int multi P5emul::Str::P5chomp ( Str *@strings = ($+_) is rw )
Related to "P5chop", only removes trailing chars that match "/\n/".
In either case, it returns the number of chars removed.
chomp
our Str method Str::chomp ( Str $string: )
Returns string with newline removed from the end. An arbitrary
terminator can be removed if the input filehandle has marked the
string for where the "newline" begins. (Presumably this is stored
as a property of the string.) Otherwise a standard newline is
removed.
Note: Most users should just let their I/O handles autochomp
instead. (Autochomping is the default.)
lc
our Str multi Str::lc ( Str $string )
our Str multi Str::lc ( Str $string = $+_ )
Returns the input string after converting each character to its
lowercase form, if uppercase.
lcfirst
our Str multi Str::lcfirst ( Str $string )
our Str multi Str::lcfirst ( Str $string = $+_ )
Like "lc", but only affects the first character.
uc
our Str multi Str::uc ( Str $string )
our Str multi Str::uc ( Str $string = $+_ )
Returns the input string after converting each character to its
uppercase form, if lowercase. This is not a Unicode "titlecase"
operation, but a full "uppercase".
ucfirst
our Str multi Str::ucfirst ( Str $string )
our Str multi Str::ucfirst ( Str $string = $+_ )
Performs a Unicode "titlecase" operation on the first character of
the string.
capitalize
our Str multi Str::capitalize ( Str $string )
our Str multi Str::capitalize ( Str $string = $+_ )
Has the effect of first doing an "lc" on the entire string, then
performing a "s:g/(\w+)/{ucfirst $1}/" on it.
length
This word is banned in Perl 6. You must specify units.
index
Needs to be in terms of StrPos, not Int.
pack
pos
quotemeta
rindex
Needs to be in terms of StrPos, not Int.
split
our List multi Str::split ( Str $delimiter , Str $input = $+_, Int $limit = inf )
our List multi Str::split ( Rule $delimiter = /\s+/, Str $input = $+_, Int $limit = inf )
our List multi Str::split ( Str $input : Str $delimiter , Int $limit = inf )
our List multi Str::split ( Str $input : Rule $delimiter , Int $limit = inf )
String delimiters must not be treated as rules but as constants.
The default is no longer ' ' since that would be interpreted as a
constant. P5's split(' ') will translate to .words or some such.
Null trailing fields are no longer trimmed by default. We might
add some kind of :trim flag or introduce a trimlist function of
some sort.
sprintf
substr
multi substr (Str $s, StrPos $start : StrPos $end, $replace)
multi substr (Str $s, StrPos $start, StrLen $length : $replace)
multi substr (Str $s, StrLen $offset : StrLen $length, $replace)
unpack
vec Should replace vec with declared arrays of bit, uint2, uint4, etc.
words
our List multi Str::words ( Rule $matcher = /\S+/, Str $input = $+_, Int $limit = inf )
our List multi Str::words ( Str $input : Rule $matcher = /\S+/, Int $limit = inf )
Control::Basic
eval
multi Control::Basic::eval ( Str $code = $+_, Grammar :$lang = CALLER::<$?PARSER>)
Execute $code as if it were code written in $lang. The default is
the language in effect at the exact location of the eval call.
Returns whatever $code returns, or undef on error.
evalfile
multi Control::Basic::evalfile (Str $filename : Grammar :$lang = Perl6)
Behaves like, and replaces Perl 5 "do EXPR", with optional $lang
support.
exit
multi Control::Basic::exit ( Int $status = 0)
Stops all program execution, and returns $status to the calling
environment.
nothing
multi Control::Basic::nothing ()
No operation. Literally does nothing.
sleep
our Num multi Control::Basic::sleep ( Num $for = Inf )
Attempt to sleep for up to $for seconds. Implementations are
obligated to support subsecond resolutions if that is at all
possible.
[Q: what about multithreading? do we just sleep this thread? need
to coordinate with entire async model. -law]
die
fail
TODO: Research the exception handling system.
Conversions
bless
sub
chr
ord Question: I think these should be strictly Code Point level
activitities, but I'm not sure. They likely need to be renamed, as
well.
list
our List multi Conversions::List::list ( *@list )
Forces List Context on it's arguements, and returns them.
item
our Item multi Conversions::Item::item ( $item )
Forces generic Item context on its argument, and returns it.
:16, :8, :2, :10
our Num multi prefix:<:16> ( Str $hexstr = $+_ )
our Num multi prefix:<:8> ( Str $octstr = $+_ )
our Num multi prefix:<:2> ( Str $binstr = $+_ )
our Num multi prefix:<:10> ( Str $decstr = $+_ )
etc.
Interprets string as a number, with a default
hexadecimal/octal/binary/decimal radix. Any radix prefix (0b, 0d,
0x, 0o) mentioned inside the string will override this operator
(this statement is true: 10 == :8 "0d10"), except 0b and 0d will be
interpreted as hex digits by :16 ("hex("0d10") == :16 "0d10"").
"fail"s on failure.
These aren't really functions, syntactically, but adverbial forms
that just happen to allow a parenthesize argument. But more
typically you'll see
:4 "222"
:16 "deadbeef"
and such.
Replaces Perl 5 "hex" and "oct".
Time::Local
gmtime
localtime
time
TODO
study
defined
undef
item
want
caller
Obsolete
dbmopen, dbmclose
use DB_File;
dump
Dumped.
each
See "Hash::kv" or "Hash::pairs" instead, and put into "for" instead
of "while". Likely there is a "Perl5::p5each" emulation though.
format, formline, write
See Exegesis 7.
/[msg|sem|shm].*/
use IPC::SysV;
ref There is no ref() any more, since it was almost always used to get
the type name in Perl 5. If you really want the type name, you can
use "$var.meta.name" or "$var.^name". If you really want P5 ref
semantics, use "Perl5::p5ref".
But if you're just wanting to test against a type, you're likely
better off performing an "isa" or "does" or "can", or just "$var ~~
TYPE".
reset
Was there a good use for this?
prototype
&func.meta.signature;
&func.^signature;
Pending Apocalypse
The following functions are classified by Apocalypse/Synopsis numbers.
A/S14: Tied Variables
tie tied untie (now implemented as container classes? my $foo is
....? is tie the meta operation on the container type for 'rebless'
- macro tie ( $var, $class, *@args ) { CODE {
variable($var).meta.rebless( $class, *@args ) } } )
These are replaced by container types. The compiler is free to
assume that any lexical variable is never going to change its
container type unless some representation is made to that effect in
the declaration. Note: P5's tied() is roughly replaced by P6's
variable().
A/S16: IPC / IO / Signals
-X accept alarm bind binmode chown close closedir connect eof fcntl
fileno flock getc getpeername
/[get|set][host|net|proto|serv|sock].*/ glob ioctl link listen
lstat mkdir open opendir pipe print printf read readdir readline
readlink readpipe recv rename rewinddir rmdir seek seekdir
select(both) send setsockopt shutdown slurp socket socketpair stat
symlink syscall sysopen sysread sysseek syswrite tell telldir
truncate umask unlink utime warn
A/S??: OS Interaction
chroot crypt exec getlogin /[get|set][pw|gr].*/ kill setpgrp
setpriority system times
... These are probably going to be part of POSIX, automatically
imported to GLOBAL iff the platform is the right one
Note: system() should be renamed to sys() or sh() or run() or some
such to avoid P5-induced boolean inversion confusion, plus
huffmanize it a little better. I'm thinking run() might be best
for MMD reasons. --law
Note: exec should also be renamed to something clearer and "final"
and huffmanly longer. I'm thinking runinstead(). And maybe the
function behind qq:x should be rungather() rather than readpipe().
-law
A/S17: Threads and Multiprocessing
fork lock wait waitpid
# FIXME audrey drafted synopsis 17
Additions
Please post errors and feedback to perl6-language. If you are making a
general laundry list, please separate messages by topic.
perl v5.14.0 2006-02-28 Perl6::Bible::S29(3)
