El Linux de cambio es diseñado para dar al usuario una experiencia de ser la parte de la comunidad Neowin así como tener un CD Vivo simple, fácil de usar que puede ser instalado a su disco duro, si usted disfruta del camino nuestros trabajos de distribución. El cambio es una distribución de Linux libre, basada en las Licencia Públicas General que puede ser libremente distribuida o modificada. No hay ningunas restricciones con el Cambio.

El Linux de cambio es un proyecto que fue creado por la comunidad Neowin (http://www.neowin.net). Basado en el Linux Morphix, el Cambio es Debian basado, por lo tanto esto tiene el acceso a todo el software y aplicaciones como otras distribuciones Debian.

Cuando desarrollamos el Cambio, decidimos producir versiones diferentes del Cambio para ordenadores con configuraciones de hardware más ligeras o más robustas. Hemos producido el Cambio con Fluxbox como el gerente de escritorio predominante, y Cambio con el Gnomo, para máquinas más cordiales. También añadiremos una versión que da al usuario la oportunidad sigue añadiendo a gerentes de escritorio diferentes cuando el tiempo continúa.

El equipo de proyecto consiste en miembros con una amplia variedad de experiencias y talentos. Cada uno ha contribuido en su / su propio camino. Si los miembros de equipo han trabajado en la distribución sí mismo, o el sitio web de Cambio, sus esfuerzos han sido dedicados a la creación de este producto de calidad.

Whats Nuevo en Esta Liberación:

· Linux de Cambio 0.5 (RC-1) es soltado. El Linux de cambio es un proyecto que fue creado por la comunidad Neowin. El Linux de Cambio de Neowins es diseñado para dar al usuario una experiencia de ser la parte de la comunidad Neowin así como tener un CD vivo simple, fácil de usar que puede ser instalado a un disco duro. El Linux de cambio 0.5 (RC-1) viene a tres ediciones totalmente marcadas: KDE, GNOMO y Fluxbox, todos los CDs vivos. Incluido en esta versión son muchos paquetes populares, apoyo inalámbrico, y un instalador de escritorio. Por favor no dude en probarlo y poner una nota cualquier error que usted puede encontrar.

BoxCheck es una extensión que usa shift+click para comprobar o no comprobar una variedad de cajas.

El formato en Guarda es un enchufe de unión de Eclipse a automáticamente organiza importaciones y formatea el código guardando a un editor de Java.

Esto es el equivalente exacto como hacer el Ctrl-Shift-O, Ctrl-Shift-F antes de guardar. Nuevos aspectos: - Miembros de Clase y Sangría Correcta - página de preferencias para configurar faltas

Opóngase el Mediador:: es un marco de persistencia de objeto genérico.

SINOPSIS

paquete Persistente;

use la base qw (Objeto:: Mediador);

__ PAQUETE __-> mk_attr (qw (foo barra));

suscripción _set_id {
mi $self = cambio;

mi $id = generate_identity ();

$self-> identidad ($id);
}

suscripción _insert {
mi $self = cambio;

$db_handle-> encarte ($self-> identificación, $self-> foo, $self-> barra);
}

suscripción _update {
mi $self = cambio;

$db_handle-> actualización ($self);
}

suscripción _delete {
mi $self = cambio;

El $db_handle-> borra ($self-> identificación);
}

suscripción _select {
mi $self = cambio;

mi ($foo, $bar) = $db_handle-> escogido ($self-> identificación);

$self-> foo ($foo);
$self-> barra ($bar);
}

Opóngase el Mediador:: intenta ser simple y justamente minimalistic marco de trazando un mapa de objeto. Los objetivos principales del desarrollo eran: simplicidad de uso, transparencia de usuario final, independencia de base de datos y minimización de interacción de base de datos con una especie de sistema de control estatal de objeto en la memoria.

Los ShiftJIS:: Confrontan es una colación de cuerdas de Shift-JIS.

SINOPSIS

use ShiftJIS:: Confrontan;

@sorted = ShiftJIS:: Confrontan-> nuevo (%tailoring)-> clase (@source);

Este módulo proporciona algunas funciones para comparar y clasificar cuerdas en el Shift-JIS basado en JIS X 4061:1996, colación de cadenas de caracteres japonesas, "Nihongo mojiretsu shogo junban".

Este módulo es una realización de JIS X 4061:1996 y las reglas de colación están basadas en aquel estándar. Ver la Conformidad al Estándar.

LAS REVOLUCIONES POR MINUTO:: Util:: Archivos son un módulo Perl para generar la lista de %files en REVOLUCIONES POR MINUTO Specfile.

SINOPSIS

use REVOLUCIONES POR MINUTO:: Util:: Archivos;

mi $util = REVOLUCIONES POR MINUTO:: Util:: Archivos-> nuevo ({
build_root =>/var/tmp/some-package-version-root,
docs_filters => [
suscripción {
mi $entry = cambio;

$entry de devolución = ~ / manuales/;
}
],
config_filters => [
suscripción {
mi $entry = cambio;

$entry de devolución = ~/.conf$/;
}
],
});

$util-> make_files;
$util-de letra> to_string;

File::FindByRegex es una envoltura Perl para File::Find que encuentra un árbol de directorio y ejecuta un poco de acción para cada archivo cuyo nombre matchs un regex.

SYNOPSYS

use File::FindByRegex;

$find = Archivo:: FindByRegex-> nuevo ({

-srcdir => [C:tmpteradata-sql],
-tardir => C:tmpteradata-sqldoc,
- encuentran => {no_chdir => 1},

- rellamadas =>
{
qr/.p (l|m|od|t) $/oi, => &treat_pod,
qr/sql. ¿+?. sql$/oi, => treat_pod,
¿qr/.html? $/oi, => &treat_html,
qr/.txt$/oi => &treat_txt,
qr/. (jpg|gif|png|bmp|tiff) $ / => suscripción {&treat_graphic (_)}
},

- no hacen caso =>
[
qr/eg. +. sql$/oi, # *.sql en directorio eg
qr/java/oi, # Todos los archivos en directorio de java.
],

-excepts =>
[
¿qr/java. *?. ¿html? El $/oi # dont no hace caso de *.html en java /
]
});

suscripción File::FindByRegex::treat_pod
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_html
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_txt
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_graphic
{
mi $this = cambio;
...
}

$find-> travel_tree;

El SystemC:: Netlist:: Red es un módulo Perl que proporciona Red a un Módulo SystemC.

Esto es una superclase de Verilog:: Netlist:: Red, sacadas para un SystemC netlist alfiler.

Análisis sintáctico de ejemplo:

@example
paquete Trialparser;
@@ ISA = qw (SystemC:: Analizador sintáctico);

módulo de suscripción {
mi $self = cambio;
mi $module = cambio;
$self-de letra> nombre del archivo. ": $self-de ".> lineno ().": ";
la letra "Contiene la declaración de módulo para el $modulen";
@}

paquete principal;
mi $sp = Trialparser-> nuevo ();
El $sp-> leyó ("test.sp");
Ejemplo de @end

Ejemplo de Netlist:

@example
use SystemC:: Netlist;

mi $nl = nuevo SystemC:: Netlist ();
foreach mi $file (testnetlist.sp) {
$nl-> read_file (nombre del archivo => $file,
strip_autos => 1);
@}
$nl-> enlace ();
$nl-> automóviles ();
$nl-> hilas ();
$nl-> exit_if_error ();

foreach mi $mod ($nl-> modules_sorted) {
show_hier ($mod, "");
@}

suscripción show_hier {
mi $mod = cambio;
mi $indent = cambio;
$indent de letra, "Módulo", $mod-> nombre, "n";
foreach mi $cell ($mod-> cells_sorted) {
show_hier ($cell-> submod, $indent. "". $cell-> nombre. "");
@}
@}
Ejemplo de @end

Opóngase la Relación:::: Meta:: el Tipo es un Objeto:: validación de tipo de Datos de Relación y edificio de accessor.

Sinopsis

Opóngase la Relación:::: Meta:: Tipo-> añaden (
tecla => "estado",
llame => "estado",
constructor => Objeto:: Relación:: Meta:: AccessorBuilder,
¿materia prima => suscripción {en cuanto a $ _ [0]? cambio-> valor: cambie},
store_raw => suscripción {cambio-> store_value},
compruebe => suscripción {
:: uNIVERSAL isa ($ _ [0], Opóngase la Relación:::: DataType:: estado)
o el throw_invalid ([el Valor "[_1]" no es un válido [_2] objeto,
$ _ [0], Opóngase la Relación:::: DataType:: estado]);
el throw_invalid ([no Puede adjudicar el estado permanente])
si $ _ [0] == Object::Relation::DataType::State->PERMANENT;
}
);

Esta Clase de subclases de clase:: Meta:: Tipo para proporcionar atributos adicionales. Estos atributos pueden ser opcionalmente puestos vía la llamada a nuevo (), y pueden ser traídos vía su accessors.

CGI::Application::Plugin::Authentication::Store es un módulo bajo para construir clases de almacenaje para el interfaz común de pasarela:: Aplicación:: Enchufe de unión:: enchufe de unión de Autentificación.

SINOPSIS

paquete CGI::Application::Plugin::Authentication::Store::MyStore;
use la base qw (CGI::Application::Plugin::Authentication::Store);

esfuerzo de suscripción {
mi $self = cambio;
mi @params = _;
...
}

la suscripción guarda {
mi $self = cambio;
mi %params = _;
...
}

la suscripción borra {
mi $self = cambio;
mi @params = _;
...
}

Este módulo es una clase baja para todas las clases de almacenaje para el interfaz común de pasarela:: Aplicación:: Enchufe de unión:: enchufe de unión de Autentificación. Se requiere que cada clase de almacenaje proporcione tres métodos que traen, guardan y borran datos de la tienda. La información que es guardada será el texto basado, así no hay ninguna necesidad de aplanar cualquiera de los datos que debe ser almacenado.

QLiss3D da 3d-Lissajous-figures (cifras hechas de un seno diferente funciona para cada dimensión) con un interfaz de Qt.

Usted puede mirar a las cifras de cualquier inspección le colocan como y hasta "escuchan" el sonido de las cifras.

Éstos son los mandos para el Qt-artefacto QLiss3D usado con QLiss3d:

gire teclas del cursor, arrastramiento de ratón
reinicio que ve página de ángulo / página abajo
cambie el valor en color rojo r / t
cambie el valor en color verde g / h
cambie el valor en color azul b / n
acerque y + / -
x cambio de fase y / x
y cambio de fase un / s
z cambio de fase q / w
información de botón de madera i
el número de cambio del encarte de puntos dibujado / suprime

Whats Nuevo en Esta Liberación:

· traducción galesa
· algunas mejoras menores que el dont tiene que ser mencionado

Sidebar de Complementos es una extensión Firefox que le deja ver sus Complementos en el sidebar pulsando el Ctrl+Shift+E.

Extensión pequeña y simple: ¡SÓLO 2 KILOBYTES!

¡Sólo los trabajos en el desarrollo construyen con el nuevo Gerente de Complementos!

Dont instalan esto si usted tiene Firefox 1.5.0.x o más abajo.

Ponga:: en una lista RewriteElements es un módulo Perl que puede crear una nueva lista volviendo a escribir elementos de una primera lista.

SINOPSIS

use la Lista:: RewriteElements;

Constructor

El caso más simple: Insumo de matriz, producción a STDOUT.

El $lre = Pone:: en una lista RewriteElements-> nuevo ({
ponga en una lista => @source,
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
} );
Insumo de archivo, producción a STDOUT:
El $lre = Pone:: en una lista RewriteElements-> nuevo ({
archivo => "/path/to/source/file",
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
} );
Proporcione una regla diferente al primer elemento en la lista:
El $lre = Pone:: en una lista RewriteElements-> nuevo ({
archivo => "/path/to/source/file",
header_rule => suscripción {
mi $record = cambio;
$record. = q {CABECERA ADICIONAL};
},
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
} );
Insumo de archivo, producción a archivo:
El $lre = Pone:: en una lista RewriteElements-> nuevo ({
archivo => "/path/to/source/file",
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
output_file => "/path/to/output/file",
} );
Para llamar el archivo de producción, sólo proporcione un sufijo al nombre del archivo:
El $lre = Pone:: en una lista RewriteElements-> nuevo ({
archivo => "/path/to/source/file",
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
output_suffix =>.out,
} );
Proporcione criterios para suprimir la producción de cabecera o registro individual.
El $lre = Pone:: en una lista RewriteElements-> nuevo ({
archivo => "/path/to/source/file",
header_suppress => suscripción {
mi $record = cambio;
vuelva si $record = ~ / $somepattern/;
},
body_suppress => suscripción {
mi $record = cambio;
vuelva si $record ne somestring;
},
body_rule => suscripción {
mi $record = cambio;
$record. = q {espacio adicional};
},
} );

Genere Producción

$lre-> generate_output ();

Información de Producción de Informe

$path_to_output_file = $lre-> get_output_path ();

$output_file_basename = $lre-> get_output_basename ();

$output_row_count = $lre-> get_total_rows ();

$output_record_count = $lre-> get_total_records ();

$records_changed = $lre-> get_records_changed ();

$records_unchanged = $lre-> get_records_unchanged ();

$records_deleted = $lre-> get_records_deleted ();

$header_status = $lre-> get_header_status ();

Es común en muchas situaciones para usted recibir un fichero de datos llano de alguien más y tener para generar un nuevo archivo en el cual cada fila o registro en el archivo de entrada deben cualquiera (a) ser transformado según alguna regla antes de ser imprimir al nuevo archivo; (o b) si esto encuentra ciertos criterios, no producción al nuevo archivo en absoluto.

Ponga:: en una lista RewriteElements le habilita para escribir tales reglas y criterios, generar el archivo de archivos de datos transformados, y recuperar un poco de estadística básica sobre la transformación.

Ponga:: en una lista RewriteElements es útil cuando el número de archivos en el archivo de entrada puede ser grande y usted no quiere sostener la lista entera en la memoria. Del mismo modo, los archivos recién generados no son sostenidos en la memoria, pero son inmediatamente impresos a STDOUT o al archivo.

Por otra parte, si por la razón que sea usted ya tiene una matriz de archivos en la memoria, usted puede usar la Lista:: RewriteElements para aplicar reglas y criterios a cada elemento de la matriz y luego imprimir los archivos transformados (otra vez, sin sostener la producción en la memoria).

La Clase:: de la prueba es un módulo Perl que permite que usted cree fácilmente clases de prueba en un estilo de xUnit/JUnit.

SINOPSIS

Ejemplo de paquete:: Prueba;
use la base qw (Prueba:: Clase);
use la Prueba:: Más;

# los métodos de instalador son ejecutados antes de cada método de prueba.
suscripción make_fixture: Prueba (instalador) {
mi $array = [1, 2];
cambio-> {test_array} = $array;
};

# un método de prueba que ejecuta 1 prueba
suscripción test_push: Prueba {
mi $array = cambio-> {test_array};
empuje $array, 3;
is_deeply ($array, [1, 2, 3], el empuje trabajó);
};

# un método de prueba que ejecuta 4 pruebas
suscripción test_pop: Prueba (4) {
mi $array = cambio-> {test_array};
es (música pop $array, 2, música pop = 2);
es (música pop $array, 1, música pop = 1);
is_deeply ($array, [], matriz vacía);
es (música pop $array, undef, música pop = undef);
};

# los métodos de desmontaje son ejecutados después de cada método de prueba.
desmontaje de suscripción: Prueba (desmontaje) {
mi $array = cambio-> {test_array};
el diag ("ponen en orden = ($array) después de la prueba (s)");
};
más tarde en un archivo.t cercano
¡#!/usr/bin/perl
use el Ejemplo:: Prueba;

# ejecute todos los métodos de prueba en el Ejemplo:: Prueba
Pruebe la Clase::-> runtests;

Producciones:

1.. 5
okey 1 - revientan = 2
okey 2 - revientan = 1
okey 3 - ponen en orden vacío
okey 4 - revientan = undef
# ponga en orden = () después de la prueba (s)

okey 5 - el empuje trabajó
# ponga en orden = (1 2 3) después de la prueba (s)

El Blatte:: HTML es un módulo Perl que contiene herramientas para generar el HTML con Blatte.

SINOPSIS

use Blatte;
use Blatte:: Builtins;
use Blatte:: HTML;

El $perl = &Blatte::Parse (... serie de Blatte codifican...);
$val = eval $perl;
&Blatte::HTML::render ($val, &emit);

la suscripción emite {
cambio de letra;
}

El POE:: Componente:: Apoderado:: TCP es un apoderado de TCP simplificado.

SINOPSIS

use POE qw (Componente:: Apoderado:: TCP);
POE:: Componente:: Apoderado:: TCP-> nuevo
(Alias => "ProxyServerSessionAlias",
Puerta => $local_server_port,
OrigPort => $remote_server_port,
OrigAddress => $remote_server_host,
DataFromClient => &data_from_client_handler,
DataFromServer => &data_from_server_handler,
);


# es llamado con datos pasados del servidor.
# llamado dentro el por cliente conectó la sesión creada por PoCo:: Servidor:: TCP
suscripción data_from_server_handler {
mi $server_data = cambio;
# espectáculo obteniendo otra información de sesión esp por información de sesión por poderes
};

# es llamado con datos pasados del cliente remoto
#
suscripción data_from_client_handler {
mi $server_data = cambio;
};

# espectáculo obteniendo otra información de sesión esp por información de sesión por poderes
# Variables de MONTÓN reservadas:

El $heap-> {mí} = Apoderado se opone / caso var picadillo
El $heap-> {mí}-> losta materia añade la documentación
[haga el por de conexión]
EJEMPLO ^
use advertencias;
use estricto;
use el diagnóstico;
use POE;
use POE:: Filtro:: Corriente;
use POE:: Filtro:: Línea;
use POE:: Componente:: Apoderado:: TCP;
$|++;

POE:: Componente:: Apoderado:: TCP-> nuevo
(Alias => "ProxyServerSessionAlias",
Puerta => 4000,
OrigPort => 5000,
OrigAddress => "localhost",
DataFromClient => suscripción {imprimen "del cliente:", cambio (), "n";},
DataFromServer => suscripción {imprimen "del servidor:", cambio (), "n";},
RemoteClientFilter => "POE:: Filtro:: Corriente",
RemoteServerOutputFilter => "POE:: Filtro:: Corriente",
RemoteServerInputFilter => "POE:: Filtro:: Corriente"
);

$poe_kernel-> ejecutado ();
salida 0;

CHASQUEE:: Prog:: el Doctor es un objeto de documento para pasar para Chasquear-e indexer.

SINOPSIS

# SILBIDO de subclase:: Prog:: Doctor
# y cree _filter () métodos

embale Mi:: Prog:: Doctor
use la base qw (CHASQUEE:: Prog:: Doctor);

suscripción url_filter
{
mi $doc = cambio;
mi $url = $doc-> url;
$url = ~ s/my.foo.com/my.bar.org/;
$doc-> url ($url);
}

suscripción content_filter
{
mi $doc = cambio;
mi $buf = $doc-> contenido;
$buf = ~ s/foo/bar/gi;
$doc-> contenido ($buf);
}

1;

CHASQUEE:: Prog:: el Doctor es la clase baja para los objetos de Doctor en el SILBIDO:: Prog marco. El doctor se opone son creados y devueltos por el SILBIDO:: Prog-> esfuerzo () método.

Usted puede subclasificar el SILBIDO:: Prog:: Doctor y añadir _filter () métodos de cambiar los valores del objeto de Doctor antes de que sea devuelto del esfuerzo ().
Si usted subclasifica el SILBIDO:: Prog, usted DEBE subclasificar el SILBIDO:: Prog:: Doctor también, aun si sólo como un placeholder.

Ejemplo:

paquete MyApp:: Prog;
use la base qw (CHASQUEE:: Prog);

suscripción okey
{
mi $self = cambio;
mi $doc = cambio;

1; # todo es permitido (pero no todas las cosas son provechosos...)
}

1;

paquete MyApp:: Prog:: Doctor; # debe usar mismo nombre de clase bajo que encima

1;

El proyecto de Superswitcher es más reemplazo de aspecto-ful del comportamiento de cambiando de ventana de Alt-Tab.

SuperSwitcher es un (más aspecto-ful) reemplazo para la ventana de Alt-Tab
cambiar el comportamiento y el comportamiento de cambiando de zona de trabajo Ctrl-Alt-Left/Right/Up/Down que es proporcionado actualmente por Metacity.

Ejecutándose, use la tecla "Súper" (también conocido como la tecla "de Windows") para cambiar entre ventanas y zonas de trabajo. Esta tecla es por lo general encontrada entre el Ctrl y teclas Alt en el teclado.

Los trabajos de superpaleta justo como el Alt-Tab hacen (con y sin el Cambio), sino también:

Super y Superabajo ciclos por todas las ventanas en la zona de trabajo corriente en una orden fija (a diferencia de Alt-Tab o Superpaleta, cuya lista de ventanas es pedida por "el más recientemente usado" primera - que está bien si usted quiere ventanas recientemente usadas, pero su torpe al ciclo por, por ejemplo, tres o cuatro ventanas en una zona de trabajo). Domine el Cambio para pedir de nuevo la lista en vez de cambiar entre ventanas.

Super-PageUp y Super-PageDown maximizan y minimizan la ventana activa (o los restaura si fuera maximizado ya o minimizado). Super-Ctrl-PageUp y Super-Ctrl-PageDown hacen esto a todas las ventanas en la zona de trabajo corriente, no sólo el activo.

Superdejado y ciclos Supercorrectos por sus zonas de trabajo. Domine el Cambio
traer también a través de la ventana activa en la nueva zona de trabajo. Domine el Cambio y Ctrl para traer a través de todas las ventanas de una zona de trabajo al siguiente. A Diferencia de Ctrl-Alt-Left Metacitys y Ctrl-Alt-Right, esto "repeticiones" de modo que, cuando usted se pone al final de la lista, usted ciclo atrás al principio.

Super-F1 se mueve a la zona de trabajo el número 1, Super-F2 se mueve a la zona de trabajo el número 2, etcétera, hasta Super-F12. Otra vez, domine el Cambio para traer a través de la ventana activa, y ambo Cambio y Ctrl para traer a través de una multitud de ventanas, justo como como descrito encima.

El superencarte crea una zona de trabajo nueva, vacía. Otra vez, domine el Cambio a también
traiga a través de la ventana activa (si hay) en la nueva zona de trabajo.

Superborre borra la zona de trabajo corriente, si es vacío. "El cambio súper borra" borrará todas las zonas de trabajo vacías, abajo a mínimo de uno.

La superfuga cierra la ventana activa. Super-Ctrl-Escape cerrará todas las ventanas en esta zona de trabajo.

Mientras la dominación de Súper, tecleando cartas regulares o números le mostrará sólo aquellas ventanas cuyo partido de títulos aquel modelo. El Apretamiento del Enter (dominando todavía Súper) va entonces el ciclo por los partidos, sin tener en cuenta cual zona de trabajo usted es conectado. Por ejemplo, si usted tiene muchas ventanas abiertas, y usted quiere ponerse a su ventana de navegador de web que muestra planet.gnome.org, luego dominar Súper, luego teclear "p" "l" "a" "Escriben" y luego sueltan la tecla Súper.

El Shift-Enter entra en la otra dirección que Entran (es decir, y dejado con
Cambio, contra abajo y directamente sin Cambio). Use la tecla Espacial para entrar
fragmentos de palabra múltiples, tal como "pla gn", para refinar adelante su búsqueda.

Finalmente, dominando Súper, haga clic en imagen o texto que representa una ventana o una zona de trabajo para activarlo.

El edificio, Instalando, Ejecutándose:

Construir (e instalar), el estándar

./autogen.sh - prefijo =/usr
hacer
(y opcionalmente) los sudo hacen instalan

debería trabajar. Después de esto, src/superswitcher sólo ejecutado. Esto escuchará
indefinidamente para prensas claves Súper, hasta que usted mate el proceso (p.ej, con
Ctrl-C).

Disfrutan mejor de SuperSwitcher si usted automáticamente comienza el programa
siempre que usted acceda. Para hacer esto, del Sistema-> Preferencias-> Sesiones, va a la paleta de Programas de Inicializador y añade superswitcher.

La suscripción:: Parecido a una cotización es un módulo Perl que permite definir funciones parecidas a una cotización.

SINOPSIS

use la Suscripción:: Parecido a una cotización;

suscripción myq () {
mi $s = cambio;
# Haga algo con $s...
$s de devolución;
}

suscripción myqq ("") {
mi $s = cambio;
# Haga algo con $s...
$s de devolución;
}

imprima myq/abc def/;
imprima myqq {$def de abecé @ghin};

ninguna Suscripción:: Parecido a una cotización; # rechaza funciones parecidas a una cotización
# en el código restante

Este módulo permite definir funciones parecidas a una cotización, que imitan la sintaxis de los operadores incorporados q (), qq (), qw (), etc.

Para definir una función parecida a una cotización que interpola el texto citado, use el nuevo ("") prototipo. Para no interpolar funciones, use (). Thats todos.

Para ser cortés con algún indenters y sintaxis highlighters, prototipo () y ("") es aceptado como sinónimos para () y ("").

La suscripción:: Afirma - diseño por el Contrato como pre y postcondiciones, etc.

SINOPSIS

use la Suscripción:: Afirman;

suscripción squareroot {
mi $x = cambio;
$x de devolución ** 0.5;
}

afirmar
pre => $PARAM [0]> = 1, # por simplicidad
ponga una nota => $VOID o $RETURN <= $PARAM [0],
suscripción => squareroot,
contexto => novoid,
acción => carpa;

imprima squareroot (2), "n"; # imprime 1.41421 etcétera
imprima squareroot (-1), "n"; # advierte
# "La condición previa 1 para:: principal squareroot fallado."
squareroot (2); # advierte
# ":: principal squareroot llamado en contexto vacío."

suscripción faultysqrt {
mi $x = cambio;
$x de devolución ** 2;
}

afirmar
pre => $PARAM [0]> = 1, # por simplicidad
ponga una nota => $RETURN <= $PARAM [0],
suscripción => faultysqrt;

imprima faultysqrt (2), "n"; # muere con
# "Postcondición 1 para:: principal squareroot fallado."