ALGOL 68

ALGOL 68, como su nombre indica, es una continuación del lenguaje ALGOL, formalizado por primera vez en 1960. Ese mismo año, la Federación Internacional para el Procesamiento de la Información (IFIP) creó el Grupo de Trabajo sobre ALGOL, o WG2.1. Este grupo publicó una especificación actualizada de ALGOL 60 en Roma en abril de 1962. En una reunión posterior, celebrada en marzo de 1964, se acordó que el grupo comenzaría a trabajar en dos estándares sucesores: ALGOL X, que sería una redefinición del lenguaje con algunas adiciones, y ALGOL Y , que tendría la capacidad de modificar sus propios programas al estilo del lenguaje LISP . ^{[ 16 ]}

La primera reunión del grupo ALGOL X se celebró en la Universidad de Princeton en mayo de 1965. Un informe de la reunión destacó dos temas ampliamente respaldados: la introducción de la tipificación fuerte y el interés en los conceptos de Euler de "árboles" o "listas" para el manejo de colecciones. ^{[ 17 ]} Aunque se concibió como una "solución a corto plazo a las dificultades existentes", ^{[ 18 ]} ALGOL X llegó a tener un compilador. Este compilador fue escrito por Douglas T. Ross del Instituto Tecnológico de Massachusetts (MIT) con el sistema Automated Engineering Design (AED-0), también denominado ALGOL Extended for Design . ^{[ 19 ] [ 20 ]}

En la segunda reunión, celebrada en octubre en Francia, se presentaron tres propuestas formales: ALGOL W de Niklaus Wirth , junto con comentarios sobre estructuras de registros de CAR (Tony) Hoare ; un lenguaje similar de Gerhard Seegmüller; y un artículo de Adriaan van Wijngaarden sobre "Diseño y descripción ortogonal de un lenguaje formal". Este último, escrito en una "gramática W" casi indescifrable, resultó ser un punto de inflexión decisivo en la evolución del lenguaje. La reunión concluyó con el acuerdo de que van Wijngaarden reescribiría la propuesta de Wirth/Hoare utilizando su gramática W. ^{[ 17 ]}

Esta tarea, aparentemente sencilla, resultó ser más difícil de lo esperado, y la reunión de seguimiento tuvo que posponerse seis meses. Cuando se reunió en abril de 1966 en Kootwijk , el borrador de van Wijngaarden seguía incompleto y Wirth y Hoare presentaron una versión con descripciones más tradicionales. En general, se acordó que su documento era «el lenguaje correcto en el formalismo equivocado». ^{[ 21 ]} A medida que se exploraban estos enfoques, quedó claro que existía una diferencia en la forma en que se describían los parámetros que tendría efectos en el mundo real, y aunque Wirth y Hoare protestaron porque más retrasos podrían volverse interminables, el comité decidió esperar la versión de van Wijngaarden. Wirth entonces implementó su definición actual como ALGOL W. ^{[ 22 ]}

En la siguiente reunión en Varsovia en octubre de 1966, ^{[ 23 ]} hubo un informe inicial del Subcomité de E/S que se había reunido en el Laboratorio Nacional de Oak Ridge y la Universidad de Illinois pero que aún no había logrado mucho progreso. Las dos propuestas de la reunión anterior se exploraron nuevamente, y esta vez surgió un nuevo debate sobre el uso de punteros ; ALGOL W los usaba solo para referirse a registros, mientras que la versión de van Wijngaarden podía apuntar a cualquier objeto. Para aumentar la confusión, John McCarthy presentó una nueva propuesta para la sobrecarga de operadores y la capacidad de encadenar construcciones and y or , y Klaus Samelson quería permitir funciones anónimas . En la confusión resultante, hubo cierta discusión sobre abandonar todo el esfuerzo. ^{[ 22 ]} La confusión continuó durante lo que se suponía que sería la reunión de ALGOL Y en Zandvoort en mayo de 1967. ^{[ 17 ]}

Finalmente, en febrero de 1968 se publicó un borrador del informe. Esto provocó «conmoción, horror y disidencia» ^{[ 17 ]} , principalmente debido a los cientos de páginas de gramática ilegible y terminología extraña. Charles H. Lindsey intentó descifrar el «lenguaje oculto en él» ^{[ 24 ],} un proceso que requirió seis semanas de trabajo. El documento resultante, «ALGOL 68 con menos lágrimas» ^{[ 25 ]} , tuvo una amplia difusión. En una reunión más amplia sobre procesamiento de información celebrada en Zúrich en mayo de 1968, los asistentes se quejaron de que se les estaba imponiendo el lenguaje y de que IFIP era «el verdadero culpable de esta situación irracional», ya que las reuniones eran mayoritariamente a puerta cerrada y no existía un mecanismo formal de retroalimentación. Wirth y Peter Naur renunciaron formalmente a sus cargos de autores en el WG2.1 en ese momento ^{[ 24 ] .}

La siguiente reunión del WG2.1 tuvo lugar en Tirrenia en junio de 1968. Se suponía que iba a tratar el lanzamiento de compiladores y otros asuntos, pero en su lugar degeneró en una discusión sobre el idioma. Van Wijngaarden respondió diciendo (o amenazando) que solo publicaría una versión más del informe. Para entonces, Naur, Hoare y Wirth habían abandonado el proyecto, y varios más amenazaban con hacerlo. ^{[ 26 ]} Le siguieron varias reuniones más: North Berwick en agosto de 1968 y Múnich en diciembre, que dieron lugar a la publicación del Informe oficial en enero de 1969, pero también a la redacción de un controvertido Informe de la Minoría. Finalmente, en Banff, Alberta , en septiembre de 1969, el proyecto se consideró generalmente completo y la discusión se centró principalmente en las erratas y en una Introducción al Informe mucho más amplia. ^{[ 27 ]}

El proyecto duró cinco años, agotó a muchos de los nombres más importantes de la informática y, en varias ocasiones, se estancó debido a problemas tanto en la definición como en el grupo en su conjunto. Hoare publicó casi de inmediato una «Crítica de ALGOL 68» ^{[ 28 ]} , que ha sido ampliamente citada en numerosas obras. Wirth continuó desarrollando el concepto de ALGOL W y lo lanzó como Pascal en 1970.

• "Una breve historia del Algol 68"
• ALGOL 68 – ALGOL de tercera generación

• Marzo de 1968: Borrador de informe sobre el lenguaje algorítmico ALGOL 68 ^{[ 40 ]} – Editado por: Adriaan van Wijngaarden , Barry J. Mailloux , John Peck y Cornelis HA Koster .

• Octubre de 1968: Informe preliminar sobre el lenguaje algorítmico ALGOL 68 — Capítulos 1–9 ^{[ 41 ]} Capítulos 10–12 ^{[ 42 ]} — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck y CHA Koster.
• Diciembre de 1968: Informe sobre el lenguaje algorítmico ALGOL 68 - Separata de Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. ^{[ 43 ]} — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck y CHA Koster.
• Marzo de 1970: Informe de la minoría, Boletín ALGOL AB31.1.1 — firmado por Edsger Dijkstra , Fraser Duncan , Jan Garwick , Tony Hoare , Brian Randell , Gerhard Seegmüller , Wlad Turski y Mike Woodger .
• Septiembre de 1973: Informe revisado sobre el lenguaje algorítmico Algol 68 - Springer-Verlag 1976 ^{[ 44 ]} - Editado por: A. van Wijngaarden, B. Mailloux, J. Peck, K. Koster, Michel Sintzoff , Charles H. Lindsey , Lambert Meertens y Richard G. Fisker .
• Otros miembros del WG 2.1 activos en el diseño de ALGOL 68: ^{[ 13 ]} Friedrich L. Bauer • Hans Bekic • Gerhard Goos • Peter Zilahy Ingerman • Peter Landin • John McCarthy • Jack Merner • Peter Naur • Manfred Paul • Willem van der Poel • Doug Ross • Klaus Samelson • Niklaus Wirth • Nobuo Yoneda .

1968: El 20 de diciembre de 1968, el Grupo de Trabajo adoptó el «Informe Final» (MR 101), que posteriormente fue aprobado por la Asamblea General del IFIP de la UNESCO para su publicación. Se realizaron traducciones de la norma al ruso , alemán , francés y búlgaro , y más tarde al japonés y al chino . ^{[ 45 ]} La norma también se puso a disposición en Braille .

1984: El TC 97 consideró la estandarización de ALGOL 68 como "Nuevo elemento de trabajo" TC97/N1642.Alemania Occidental, Bélgica, los Países Bajos, la URSS y Checoslovaquia estaban dispuestas a participar en la elaboración de la norma, pero la URSS y Checoslovaquia "no eran el tipo de miembros adecuados para los comités ISO adecuados".y la estandarización ISO de Algol 68 se estancó.

1988: Posteriormente, ALGOL 68 se convirtió en una de las normas GOST en Rusia.

• GOST 27974-88 Lenguaje de programación ALGOL 68 — Язык программирования АЛГОЛ 68 ^{[ 46 ]}
• GOST 27975-88 Lenguaje de programación ALGOL 68 extendido — Язык программирования АЛГОЛ 68 расширенный ^{[ 47 ]}

El idioma estándar contiene alrededor de sesenta palabras reservadas, generalmente en negrita en la versión impresa, y algunas con equivalentes de "símbolo breve":

MODO , OP , PRIORIDAD , PROC , FLEXIBLE , MONTON, UBICACIÓN, LARGO, REF, CORTO, BITS, BOOL, BYTES, CARÁCTER, COMPL, INT, REAL, SEMA, CADENA, VACÍO, CANAL, ARCHIVO, FORMATO, ESTRUCTURA, UNIÓN, EN " @ " , EITHER r0 , IS " : = : " , ISNT IS NOT r0 " : / = : " " : ≠ : " , OF " → " r0 , VERDADERO , FALSO , VACÍO , NIL " ○ " , SALTAR " ~ " , CO " ¢ " , COMENTARIO " ¢ " , PR , PRAGMAT , CASE ~ IN ~ OUSE ~ IN ~ OUT ~ ESAC " ( ~ | ~ |: ~ | ~ | ~ )", FOR ~ FROM ~ TO ~ BY ~ MIENTRAS ~ HACER ~ OD , SI ~ ENTONCES ~ SINO ~ SI ~ ENTONCES ~ SINO ~ FI " ( ~ | ~ |: ~ | ~ | ~ )", PAR BEGIN ~ END "( ~ )", IR A , IR A , SALIR "□" r0 .

La construcción básica del lenguaje es la unidad . Una unidad puede ser una fórmula , una cláusula cerrada , un texto rutinario o una de varias construcciones técnicamente necesarias (asignación, salto, omisión, nihil). El término técnico cláusula cerrada unifica algunas de las construcciones inherentemente de corchetes conocidas como bloque , instrucción do , instrucción switch en otros lenguajes contemporáneos. Cuando se usan palabras clave, generalmente se usa la secuencia de caracteres invertida de la palabra clave introductoria para terminar la clausura, por ejemplo ( IF ~ THEN ~ ELSE ~ FI , CASE ~ IN ~ OUT ~ ESAC , FOR ~ WHILE ~ DO ~ OD ). Esta sintaxis de Comando Protegido fue reutilizada por Stephen Bourne en el shell Bourne común de Unix . Una expresión también puede producir un valor múltiple , que se construye a partir de otros valores mediante una cláusula colateral . Esta construcción se parece al paquete de parámetros de una llamada a procedimiento.

Los tipos de datos básicos (llamados modes en la jerga de Algol 68) son real, int, compl( número complejo ), bool, char, bitsy bytes. Por ejemplo:

INT n = 2; CO n se fija como una constante de 2. CO INT m := 3; CO m es una variable local recién creada cuyo valor se establece inicialmente en 3. CO CO Esto es una abreviatura de ref int m = loc int := 3; CO REAL avogadro = 6.0221415⏨23; CO Número de Avogadro CO long long real long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510; COMPL raíz cuadrada de menos uno = 0 ⊥ 1;

Sin embargo, la declaración REAL x;es solo azúcar sintáctico para . Es decir, es realmente el identificador constante para una referencia a una variable REAL local recién generada .REFREAL x = LOCREAL;x

Además, en lugar de definir tanto floatcomo double, o inty longy short, etc., ALGOL 68 proporciona modificadores , de modo que el actualmente común doublese escribiría como LONG REAL o LONG LONG REAL en su lugar, por ejemplo. Las constantes de preludiomax real y min long intse proporcionan para adaptar los programas a diferentes implementaciones.

Todas las variables deben ser declaradas, pero la declaración no tiene por qué preceder a su primer uso.

declarante primitivo: INT , REAL , COMPL , COMPLEX ^G , BOOL , CHAR , STRING , BITS , BYTES , FORMAT , FILE , PIPE ^G , CHANNEL , SEMA

• BITS – un "vector empaquetado" de BOOL .
• BYTES – un "vector empaquetado" de CHAR .
• STRING – una matriz FLEXIBLE de CHAR .
• SEMA : un foro SEMA que se puede inicializar con el nivel del operador OP .

Los tipos complejos se pueden crear a partir de tipos más simples utilizando varios constructores de tipos:

• Modo REF : una referencia a un valor de tipo modo , similar a & en C/C++ y REF en Pascal.
• STRUCT – se utiliza para construir estructuras, como STRUCT en C/C++ y RECORD en Pascal.
• UNION – se utiliza para construir uniones, como en C/C++ y Pascal.
• PROC – se utiliza para especificar procedimientos, como funciones en C/C++ y procedimientos/funciones en Pascal.

Otros símbolos de declaración incluyen: FLEX , HEAP , LOC , REF , LONG , SHORT , EVENT ^S

• FLEX : declara que el array es flexible, es decir, que su longitud puede aumentar según se requiera.
• HEAP : asigna una cantidad variable de espacio libre del montón global.
• LOC – asigna a la variable algo de espacio libre en la pila local.
• LONG – declara que un INT , REAL o COMPL es de un tamaño LONG .
• SHORT : declara que un INT , REAL o COMPL es de un tamaño SHORT .

Se puede declarar un nombre para un modo (tipo) utilizando una declaración MODE , que es similar a TYPEDEF en C/C++ y TYPE en Pascal:

INT max=99; MODO NUEVOMODO = [0:9][0:max] ESTRUCTURA ( LARGO REAL a, b, c, CORTO INT i, j, k, REF REAL r );

Esto es similar al siguiente código C:

const int max = 99 ; typedef struct { double a , b , c ; short i , j , k ; float * r ; } newmode [ 9 + 1 ][ max + 1 ];

Para ALGOL 68, solo aparece la indicación de modo NEWMODE a la izquierda del símbolo de igual, y lo más importante es que la construcción se realiza y se puede leer de izquierda a derecha sin tener en cuenta las prioridades. Además, el límite inferior de los arreglos de Algol 68 es uno por defecto, pero puede ser cualquier entero desde - max int hasta max int .

Las declaraciones de modo permiten que los tipos sean recursivos : definidos directa o indirectamente en términos de sí mismos. Esto está sujeto a algunas restricciones; por ejemplo, estas declaraciones son ilegales:

MODO A = REF A MODO A = STRUCT ( A a, B b) MODO A = PROC ( A a) A

mientras estos sean válidos:

MODO A = ESTRUCTURA ( REF A a, B b) MODO A = PROC ( REF A a) REF A

Las coerciones generan un objeto coaccionado a partir de un objeto coaccionado según tres criterios: el modo a priori del objeto coaccionado antes de la aplicación de cualquier coerción, el modo a posteriori del objeto coaccionado requerido después de dichas coerciones, y la posición sintáctica o "tipo" del objeto coaccionado. Las coerciones pueden ser en cascada.

Las seis coerciones posibles se denominan desprocedimiento , desreferenciación , unión , ampliación , reordenamiento y anulación . Cada coerción, excepto la unión , prescribe un efecto dinámico correspondiente sobre los valores asociados. Por lo tanto, muchas acciones primitivas pueden programarse implícitamente mediante coerciones.

Fuerza del contexto: coacciones permitidas:

• suave – desprocedimiento
• débil – desreferenciación o desprocedimiento, que produce un nombre
• manso – desreferenciación o desprocedimiento
• firme – manso, seguido de unificador
• fuerte – firme, seguido de ensanchamiento, remo o vaciado

Las pragmats (del latín "pragmatic remarks") son directivas del programa, normalmente sugerencias para el compilador; en lenguajes más recientes se denominan "pragmas" (sin "t"). Por ejemplo:

PRAGMAT montón=32 PRAGMAT PR montón=32 PR

Los comentarios pueden insertarse de diversas maneras:

¢ La forma original de aportar tu granito de arena a un programa ¢ COMENTARIO "negrita" comentario COMENTARIO CO Estilo i comentario CO # Comentario sobre el estilo ii # £ Este es un comentario de almohadilla/libra para un teclado del Reino Unido £

Normalmente, en ALGOL 68 no se pueden anidar comentarios. Esta restricción se puede sortear utilizando diferentes delimitadores de comentarios (por ejemplo, usar el símbolo de almohadilla solo para eliminar código temporalmente).

ALGOL 68 es un lenguaje de programación orientado a expresiones , por lo que el valor devuelto por una instrucción de asignación es una referencia al destino. Por lo tanto, el siguiente es código ALGOL 68 válido:

REAL medio pi, un pi; un pi := 2 * ( medio pi := 2 * arc tan(1) )

Esta noción está presente en C y Perl , entre otros. Cabe destacar que, al igual que en lenguajes anteriores como Algol 60 y FORTRAN , se permiten espacios en los identificadores, de modo que half pise trata de un único identificador (evitando así los problemas relacionados con los guiones bajos , el formato camel case y el uso exclusivo de minúsculas ).

Como otro ejemplo, para expresar la idea matemática de una suma de f(i)i=1 a n, basta con la siguiente expresión entera de ALGOL 68 :

( INT suma := 0; PARA i HASTA n HACER suma +:= f(i) HACER suma)

Cabe destacar que, al tratarse de una expresión entera, el bloque de código anterior puede utilizarse en cualquier contexto donde se admita un valor entero . Un bloque de código devuelve el valor de la última expresión evaluada; esta idea está presente en Lisp , entre otros lenguajes.

Las expresiones compuestas finalizan todas con corchetes distintivos:

• Cláusulas condicionales de elección:

SI condición ENTONCES instrucciones [ SI NO instrucciones ] FI Forma "breve": ( condición | instrucciones | instrucciones )

SI condición1 ENTONCES instrucciones SINO SI condición2 ENTONCES instrucciones [ SINO instrucciones ] FI Forma "breve": ( condición1 | instrucciones |: condición2 | instrucciones | instrucciones )

Este esquema no solo evita el problema del else colgante , sino que también evita tener que usar BEGINy ENDen secuencias de instrucciones anidadas .

• Cláusulas de elección de caso :

Sentencias CASE switch IN , sentencias,... [ OUT sentencias ] Forma "breve" de ESAC : ( switch | sentencias, sentencias,... | sentencias )

CASE switch1 IN instrucciones, instrucciones,... OUSE switch2 IN instrucciones, instrucciones,... [ OUT instrucciones ] ESAC Forma "abreviada" de la instrucción CASE : ( switch1 | instrucciones, instrucciones,... |: switch2 | instrucciones, instrucciones,... | instrucciones )

Ejemplo de cláusula Choice con símbolos Brief :

PROC días en el mes = ( INT año, mes) INT : (mes| 31, (año÷×4=0 ∧ año÷×100≠0 ∨ año÷×400=0 | 29 | 28 ), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );

Ejemplo de cláusula de elección con símbolos en negrita :

PROC días en el mes = ( INT año, mes) INT : CASO mes EN 31, SI año MOD 4 EQ 0 Y año MOD 100 NE 0 O año MOD 400 EQ 0 ENTONCES 29 SINO 28 FI , 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ESAC ;

Ejemplo de cláusula de elección que combina símbolos en negrita y breve :

PROC días en el mes = ( INT año, mes) INT : CASO mes EN 31 de enero, ¢Feb¢ (año MOD 4 = 0 Y año MOD 100 ≠ 0 O año MOD 400 = 0 | 29 | 28), ¢Mar¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ a Dic. ¢ ESAC ;

Algol68 permitía que el interruptor fuera de tipo INT o (únicamente) UNION . Este último permite imponer un tipado estricto a las variables UNION . Véase, por ejemplo, el ejemplo de unión a continuación.

• hacer cláusula de bucle:

[ PARA índice ] [ DESDE primero ] [ POR incremento ] [ HASTA último ] [ MIENTRAS condición ] Instrucciones DO OD La forma mínima de una "cláusula de bucle" es, por lo tanto: Instrucciones DO OD

Este se consideraba el bucle "universal", la sintaxis completa es:

PARA i DESDE 1 HASTA -22 HASTA -333 MIENTRAS i×i≠4444 HACER ~ OD

Esta construcción presenta varios aspectos inusuales:

• Solo la parte DO ~ OD era obligatoria, en cuyo caso el bucle iterará indefinidamente.
• por lo tanto, la cláusula TO 100 DO ~ OD se repetirá solo 100 veces.
• El "elemento sintáctico" WHILE permitía a un programador salir de un bucle FOR antes de tiempo. Por ejemplo:

INT suma de cuadrados:=0; PARA i MIENTRAS print(("Hasta ahora:",i,newline)); suma sq≠70↑2 HACER suma sq+:=i↑2 sobredosis

Las posteriores "extensiones" al estándar Algol68 permitieron reemplazar el elemento sintáctico TO por UPTO y DOWNTO para lograr una pequeña optimización. Los mismos compiladores también incorporaron:

• HASTA ^(C) – para terminación tardía del bucle.
• FOREACH ^(S) – para trabajar con matrices en paralelo .

Encontrará más ejemplos en los ejemplos de código que aparecen a continuación.

ALGOL 68 admite matrices con cualquier número de dimensiones y permite segmentar filas o columnas completas o parciales.

MODO VECTOR = [1:3] REAL ; # declaración de MODO vector (typedef) # MODO MATRIZ = [1:3,1:3] REAL ; # declaración de MODO matriz (typedef) # VECTOR v1 := (1,2,3); # variable de matriz inicialmente (1,2,3) # [] REAL v2 = (4,5,6); # matriz constante, tipo equivalente a VECTOR , los límites están implícitos # OP + = ( VECTOR a,b) VECTOR : # definición de operador binario # ( VECTOR out ; FOR i FROM ⌊a TO ⌈a DO out[i] := a[i]+b[i] OD ; out); MATRIZ m := (v1, v2, v1+v2); print ((m[,2:])); # una porción de la segunda y tercera columna #

Las matrices se pueden segmentar en cualquier sentido, por ejemplo:

REF VECTOR fila = m[2,]; # define una REF (puntero) a la segunda fila # REF VECTOR columna = m[,2]; # define una REF (puntero) a la segunda columna #

ALGOL 68 admite múltiples estructuras de campo ( STRUCT ) y modos unificados . Las variables de referencia pueden apuntar a cualquier MODO , incluyendo segmentos de matriz y campos de estructura.

Como ejemplo de todo esto, aquí está la declaración tradicional de lista enlazada:

MODO NODO = UNIÓN ( VOID , REAL , INT , COMPL , STRING ); MODO LISTA = ESTRUCTURA ( NODO val, REF LISTA siguiente);

Ejemplo de uso para UNION CASE de NODE :

Las declaraciones de procedimiento ( PROC ) requieren especificaciones de tipo tanto para los parámetros como para el resultado ( VOID si no hay ninguno):

PROC max of real = ( REAL a, b) REAL : IF a > b THEN a ELSE b FI ;

o bien, utilizando la forma "breve" de la declaración condicional:

PROC max of real = ( REAL a, b) REAL : (a>b | a | b);

El valor de retorno de `a` es el valor de la última expresión evaluada en el procedimiento. También se permiten procreferencias a procedimientos ( `ref proc` ). Los parámetros por referencia se proporcionan especificando referencias (como `ref` ref real) en la lista de argumentos formales. El siguiente ejemplo define un procedimiento que aplica una función (especificada como parámetro) a cada elemento de una matriz:

PROC apply = ( REF [] REAL a, PROC ( REAL ) REAL f): FOR i FROM LWB a TO UPB a DO a[i] := f(a[i]) OD 

Esta simplicidad de código era inalcanzable en el predecesor de ALGOL 68, ALGOL 60 .

El programador puede definir nuevos operadores , tanto estos como los predefinidos pueden sobrecargarse y sus prioridades pueden modificarse. El siguiente ejemplo define un operador MAXcon versiones diádica y monádica (recorriendo los elementos de un array).

PRIO MAX = 9; OP MAX = ( INT a,b) INT : ( a>b | a | b ); OP MAX = ( REAL a,b) REAL : ( a>b | a | b ); OP MAX = ( COMPL a,b) COMPL : ( ABS a > ABS b | a | b ); OP MAX = ([] REAL a) REAL :   ( REAL out := a[ LWB a]; PARA i DESDE LWB a + 1 HASTA UPB a HACER ( a[i]>out | out:=a[i] ) OD ; afuera)

Transput es el término utilizado para referirse a las funciones de entrada y salida de ALGOL 68. Incluye procedimientos predefinidos para la transputación sin formato, formateada y binaria. Los archivos y otros dispositivos de transputación se gestionan de forma consistente e independiente de la máquina. El siguiente ejemplo imprime una salida sin formato en el dispositivo de salida estándar :

 imprimir ((nuevapágina, "Título", nuevalínea, "El valor de i es ", yo, "y x[i] es ", x[i], salto de línea)) 

Tenga en cuenta los procedimientos predefinidos newpagey newlinelos que se pasan como argumentos.

printf (($2l"La suma es:"x, g(0)$, m + n)); ¢ imprime lo mismo que: ¢ imprimir ((nueva línea, nueva línea, "La suma es:", espacio, entero (m + n, 0)) 

ALGOL 68 admite la programación de procesamiento paralelo. Mediante la palabra clave PAR , una cláusula colateral se convierte en una cláusula paralela , donde la sincronización de las acciones se controla mediante semáforos . En A68G, las acciones paralelas se asignan a subprocesos cuando están disponibles en el sistema operativo anfitrión . En A68S se implementó un paradigma diferente de procesamiento paralelo (véase más abajo).

PROC eat = VOID : ( muffins-:=1; print(("¡Qué rico!",nueva línea))), hablar = VOID : ( palabras-:=1; imprimir(("Yak...",nueva línea))); INT magdalenas := 4, palabras := 8; SEMA boca = NIVEL 1; PAR BEGIN WHILE magdalenas > 0 DO DOWN boca;   comer; ARRIBA boca OD , MIENTRAS palabras > 0 HACER ABAJO boca; hablar; Boca ARRIBA OD FINAL

Debido a su complejidad técnica, ALGOL 68 necesita una gran variedad de métodos para negar la existencia de algo:

SKIP , "~" o "?" C – un valor indefinido siempre sintácticamente válido, EMPTY – el único valor admisible para VOID , necesario para seleccionar VOID en una UNION , VOID – sintácticamente como un MODE , pero no lo es, NIL o "○" – un nombre que no denota nada, de un modo de referencia no especificado, () o específicamente [1:0] INT : un vacío es una matriz vacía (aquí específicamente de MODO [] INT ). indefinido : un procedimiento de informes estándar que genera una excepción en el sistema de tiempo de ejecución. ℵ – Se utiliza en el informe de normas para inhibir ciertos tipos de introspección . Por ejemplo, SEMA.

El término NIL IS var siempre se evalúa como VERDADERO para cualquier variable (pero consulte arriba el uso correcto de IS  :/=:), mientras que no se sabe a qué valor se evalúa una comparación x < SKIP para cualquier entero x .

ALGOL 68 deja intencionadamente sin definir qué sucede en caso de desbordamiento de enteros , la representación de bits de enteros y el grado de precisión numérica para punto flotante.

Ambos informes oficiales incluían algunas características avanzadas que no formaban parte del lenguaje estándar. Estas se indicaban con un ℵ y se consideraban, en la práctica, privadas. Algunos ejemplos son "≮" y "≯" para plantillas, OUTTYPE / INTYPE para tipado dinámico básico , y los operadores STRAIGHTOUT y STRAIGHTIN para "enderezar" matrices y estructuras anidadas.

Este programa de ejemplo implementa la criba de Eratóstenes para encontrar todos los números primos menores que 100. NIL es el equivalente en ALGOL 68 del puntero nulo en otros lenguajes. La notación x OF y accede a un miembro x de una estructura y .

INICIO # Criba de números primos Algol-68, estilo funcional # PROC error = ( STRING s) VOID :  (print(( newline, " error: ", s, newline)); GOTO stop); PROC one to = ( INT n) LIST : ( PROC f = ( INT m,n) LIST : (m>n | NIL | cons(m, f(m+1,n))); f(1,n)); MODE LIST = REF NODE ; MODE NODE = STRUCT ( INT h, LIST t); PROC cons = ( INT n, LIST l) LIST : HEAP NODE := (n,l); PROC hd = ( LIST l) INT : ( l IS NIL | error("hd NIL "); SKIP | h OF l ); PROC tl = ( LIST l) LIST : ( l IS NIL | error("tl NIL "); SKIP | t OF l ); PROC show = ( LIST l) VOID : ( l ISNT NIL | print((" ",whole(hd(l),0))); show(tl(l))); PROC filter = ( PROC ( INT ) BOOL p, LIST l) LIST : IF l IS NIL THEN NIL ELIF p(hd(l)) THEN cons(hd(l), filter(p,tl(l))) ELSE filter(p, tl(l)) FI ; PROC sieve = ( LIST l) LIST : IF l IS NIL THEN NIL ELSE PROC not multiple = ( INT n) BOOL : n MOD hd(l) ~= 0;    cons(hd(l), sieve(filter(not multiple, tl(l)))) FI ; PROC primos = ( INT n) LISTA : tamiz( tl( uno a(n) ));    mostrar( primos(100) ) FIN

• Computadora Cambridge CAP : todos los procedimientos que constituyen el sistema operativo fueron escritos en ALGOL 68C , aunque varios otros procedimientos protegidos estrechamente asociados, como un paginador, están escritos en BCPL . ^{[ 49 ]}
• Eldon 3 – Desarrollado en la Universidad de Leeds para el ICL 1900 fue escrito en ALGOL 68-R . ^{[ 50 ]}
• Máquina Flex : el hardware era personalizado y microprogramable, con un sistema operativo, compilador (modular), editor, recolector de basura y sistema de archivos, todo escrito en ALGOL 68RS . El intérprete de comandos Curt ^{[ 51 ]} fue diseñado para acceder a datos tipados de forma similar a los modos de Algol-68.
• VME – S3 era el lenguaje de implementación del sistema operativo VME. S3 se basaba en ALGOL 68, pero con tipos de datos y operadores alineados con los ofrecidos por la serie ICL 2900 .

Nota: Las computadoras de la era soviética Elbrus-1 y Elbrus-2 se crearon utilizando el lenguaje de alto nivel AL-76, en lugar del lenguaje ensamblador tradicional. AL-76 se asemeja a Algol-68. La principal diferencia radica en los tipos de enlace dinámico que AL-76 admite a nivel de hardware. AL-76 se utiliza para aplicaciones, control de trabajos y programación de sistemas. ^{[ 52 ]}

Tanto ALGOL 68C como ALGOL 68-R están escritos en ALGOL 68, lo que convierte a ALGOL 68 en una aplicación en sí misma. Otras aplicaciones incluyen:

• ELLA : un lenguaje de descripción de hardware y un conjunto de herramientas de soporte. Desarrollado por el Royal Signals and Radar Establishment durante las décadas de 1980 y 1990.
• Sistema de mando de ataque de la RAF : "... Se produjeron 400 KB de código ALGOL 68-RT sin errores con tres años-hombre de trabajo..." ^{[ 53 ]}

• Bibliotecas numéricas NAG : una biblioteca de software con rutinas de análisis numérico . Incluida en ALGOL 68 durante la década de 1980.
• TORRIX – un sistema de programación para operaciones con vectores y matrices sobre campos arbitrarios y de tamaño variable por SG van der Meulen y M. Veldhorst. ^{[ 54 ]}

ALGOL 68 permite que cada idioma defina su propio conjunto de palabras clave. De esta forma, los programadores pueden escribir programas utilizando palabras clave de su idioma nativo. A continuación, se muestra un ejemplo de un procedimiento sencillo que calcula "el día siguiente"; el código está escrito en dos idiomas: inglés y alemán.

# Fecha del día siguiente - variante en inglés # MODO FECHA = ESTRUCTURA ( INT día, CADENA mes, INT año); PROC el día siguiente = ( FECHA x) FECHA : SI día DE x < duración del mes (mes DE x, año DE x) ENTONCES (día DE x + 1, mes DE x, año DE x) SINO SI mes DE x = "diciembre" ENTONCES (1, "enero", año DE x + 1) SINO (1, sucesor del mes (mes DE x), año DE x) FI ;

# Nachfolgetag - Deutsche Variante # MENGE DATUM = TUPEL ( etiqueta GANZ , WORT monat, GANZ jahr); FUNKTION naechster tag nach = ( DATUM x) DATUM : WENN tag VON x < monatslaenge(monat VON x, jahr VON x) DANN (tag VON x + 1, monat VON x, jahr VON x) WENNABER monat VON x = "diciembre" DANN (1, "enero", jahr VON x + 1) ANSONSTEN (1, nachfolgemonat(monat VON x), jahr VON x) ENDEWENN ;

Ejemplo ruso/soviético: En inglés, la sentencia case de Algol68 se lee CASE ~ IN ~ OUT ~ ESAC , en cirílico se lee выб ~ в ~ либо ~ быв .

El idioma original (según el "Informe final" ^r0 ) difiere en la sintaxis de la conversión de modo y tenía la característica de procedurar , es decir, convertir el valor de un término en un procedimiento que evalúa dicho término. Proceder estaría destinado a hacer evaluaciones perezosas . La aplicación más útil podría haber sido la evaluación en cortocircuito de operadores booleanos. En:

OP ANDF = ( BOOL a, PROC BOOL b) BOOL :(a | b | FALSE ); OP ORF = ( BOOL a, PROC BOOL b) BOOL :(a | TRUE | b);

b solo se evalúa si a es verdadero.

Tal como se define en ALGOL 68, no funcionó como se esperaba, por ejemplo en el código:

SI FALSO Y CO proc bool: CO ( print ("No debería ejecutarse"); VERDADERO ) ENTONCES ...

Contrariamente a las expectativas ingenuas de los programadores, la impresión se ejecutaría, ya que solo se procesó el valor de la cláusula incluida después de ANDF . La inserción textual de PROC BOOL : comentado soluciona el problema.

Algunas implementaciones emulan el comportamiento esperado para este caso especial mediante la extensión del lenguaje.

Antes de la revisión, el programador podría decidir que los argumentos de un procedimiento se evalúen de forma secuencial en lugar de colateralmente, utilizando punto y coma en lugar de comas ( gomma s).

Por ejemplo en:

PROC test = ( REAL a; REAL b) :... ... prueba (x MÁS 1, x);

Se garantiza que el primer argumento a probar se evaluará antes que el segundo, pero de la forma habitual:

PROC test = ( REAL a, b) :... ... prueba (x MÁS 1, x);

Entonces, el compilador podría evaluar los argumentos en el orden que le pareciera conveniente.

Tras la revisión del informe, se han propuesto algunas ampliaciones del lenguaje para extender su aplicabilidad:

• parametrización parcial (también conocida como currificación ): creación de funciones (con menos parámetros) mediante la especificación de algunos, pero no todos los parámetros para una llamada, por ejemplo, una función logaritmo de dos parámetros, base y argumento, podría especializarse a logaritmo natural, binario o decádico, ^{[ 55 ]}
• Extensión de módulo : para el soporte de enlaces externos, se propusieron dos mecanismos: módulos de definición ascendente , una versión más potente de las funcionalidades de ALGOL 68-R , y agujeros descendentes , similares a las cláusulas ENVIRONy de ALGOL 68C . ^{[ 56 ]}USING
• Parámetros de modo : para la implementación de polimorfismo paramétrico limitado (la mayoría de las operaciones en estructuras de datos como listas, árboles u otros contenedores de datos se pueden especificar sin tocar la carga útil). ^{[ 57 ]}

Hasta ahora, la parametrización parcial se ha implementado en Algol 68 Genie, y un subconjunto de la funcionalidad de Módulos y Compilación Separada se ha implementado en GCC.

El lenguaje S3 , utilizado para escribir el sistema operativo ICL VME y gran parte del software del sistema en la serie ICL 2900, era una derivación directa de ALGOL 68. Sin embargo, omitía muchas de las funciones más complejas y reemplazaba los modos básicos con un conjunto de tipos de datos que se correspondían directamente con la arquitectura de hardware de la serie 2900.

ALGOL 68R de RRE fue la primera implementación de un subconjunto de ALGOL 68, que se ejecutaba en el ICL 1900. Basado en el lenguaje original, las principales restricciones del subconjunto eran la definición previa al uso y la ausencia de procesamiento paralelo. Este compilador fue popular en las universidades del Reino Unido en la década de 1970, donde muchos estudiantes de informática aprendieron ALGOL 68 como su primer lenguaje de programación; el compilador era conocido por sus claros mensajes de error.

ALGOL 68RS ^(RS), de RSRE, era un sistema de compilación portátil escrito en ALGOL 68RS (basado en ALGOL 68R) e implementado en diversos sistemas, como ICL 2900 / Serie 39 , Multics y DEC VAX/VMS . El lenguaje se basaba en el Informe Revisado, pero con restricciones de subconjunto similares a las de ALGOL 68R. Este compilador aún existe como compilador de Algol68 a C.

En ALGOL 68S ^(S) de la Universidad Carnegie Mellon, la potencia del procesamiento paralelo se mejoró añadiendo una extensión ortogonal, eventing . Cualquier declaración de variable que contuviera la palabra clave EVENT hacía que las asignaciones a dicha variable fueran aptas para la evaluación paralela; es decir, el lado derecho se convertía en un procedimiento que se trasladaba a uno de los procesadores del sistema multiprocesador C.mmp . Los accesos a dichas variables se retrasaban tras la finalización de la asignación.

Cambridge ALGOL 68C ^(C) era un compilador portátil que implementaba un subconjunto de ALGOL 68, restringiendo las definiciones de operadores y omitiendo la recolección de basura, las filas flexibles y la transposición formateada.

Algol 68 Genie ^(G), de Marcel van der Veer, es una implementación de ALGOL 68 para los ordenadores y sistemas operativos actuales. El intérprete implementa una extensión: la propuesta de parametrización parcial de Charles Lindsey, publicada en 1976, que dota al lenguaje imperativo Algol 68 de un sublenguaje funcional.

La colección de compiladores GNU , GNU Algol 68, implementa varias extensiones de GNU al lenguaje, ^{[ 68 ] [ 69 ]} proporcionando un superlenguaje estricto de ALGOL 68, como lo permite explícitamente el Informe revisado. ^{[ 1 ] : 51}

"A pesar de las buenas intenciones, un programador puede violar la portabilidad al emplear inadvertidamente una extensión local. Para evitar esto, cada implementación debe proporcionar una opción pragmat PORTCHECK. Mientras esta opción esté activa, el compilador imprime un mensaje para cada construcción que reconoce como violatoria de alguna restricción de portabilidad." ^{[ 70 ]}