Programa de escritura en tu idioma favorito en otro idioma [cerrado]

168

El programador real determinado puede escribir programas Fortran en cualquier idioma.

de verdaderos programadores no usan Pascal

Su tarea es escribir el programa en el lenguaje de programación de su elección, pero solo puede usar otro idioma. Es decir, deseche todas las convenciones de codificación de un idioma y reemplácelas por convenciones de codificación de otro idioma. Mientras más, mejor. Haga que su programa se vea como si estuviera escrito en otro idioma.

Por ejemplo, un fanático de Python que odia Java podría escribir el siguiente programa Python en Java:

void my_function()                                                             {
    int i = 9                                                                  ;
    while(i>0)                                                                 {
        System.out.println("Hello!")                                           ;
        i = i - 1                                                              ;}}

El entusiasta de Pascal obligado a usar C podría escribir esto:

#define begin {
#define end }
#define then
#define writeln(str) puts(str)

if (i == 10) then
begin
    writeln("I hate C");
end

Tienes que escribir el programa completo. El programa no tiene que hacer nada útil.

Buena suerte. Este es un concurso de popularidad, por lo que gana el código con más votos.

popularity-contest el.pescado
fuente
1
@ m.buettner crea tu archivo con la extensión .litcoffee. Podría ayudar.
Ismael Miguel
Un poco largo (y previamente por escrito, y no autónomo) para una respuesta, pero: escáner de PostScript en PostScript en C .
luser droog
51
No creo que usted (o la mayoría de las respuestas) comprenda el punto de la cita. No es que un verdadero programador escriba código que se parezca léxicamente a Fortran aunque esté escribiendo en Pascal o LISP: es que aplica una forma de pensar de Fortran incluso cuando escribe en Pascal o LISP; por ejemplo, " como saben todos los programadores reales, la única estructura de datos útil es la matriz ". Grandes respuestas serían código de procedimiento en Prolog, código funcional en C, código orientado a objetos en Pascal.
Peter Taylor
1
Espero que alguien haga un dialecto Lisp, bueno, cualquier cosa menos otro dialecto Lisp ...
itsjeyd
66
Décima regla de programación de @itsjeyd Greenspun : "Cualquier programa C o Fortran suficientemente complicado contiene una implementación ad-hoc, especificada informalmente, llena de errores y lenta de la mitad de CommonLisp".
Joshua Taylor

Respuestas:

142

C en C ++

#include <stdio.h>

int main(int argc, char** argv)
{
        printf("Hello world!\n");
        return 0;
}

fuente
6060
Veo lo que hiciste allí;)
el.pescado
27
Bueno, eso es un truco barato, ya que C ++ es "compatible con versiones anteriores" con C.
Agi Hammerthief
55
@AlexM. Creo que sería más en el espíritu de la pregunta si este fuera un ejemplo más largo (de procedimiento) que claramente se beneficiaría del uso de algunas clases y que usa otras expresiones idiomáticas en C donde alguna bondad STL sería mucho más razonable (digamos en char*lugar de std::string).
Martin Ender
47
Válido en C, C ++, Objective-C y Objective-C ++! Qué maravillosa respuesta políglota.
nneonneo
77
@BenJackson Psh, ¡ los programadores reales de C usan char *argv[]!
Thomas
122

Ensamblado x86 en GNU C

No, no solo utilicé la asmpalabra clave, ya que la pregunta estableció que esto es para programadores reales ... esto debería funcionar bien en ARM.

(Solo para probar el punto, no "escribí" el ensamblaje en absoluto: es el resultado producido por GCC Clang (503.0.38) para el código comentado en la parte superior, traducido ciegamente a macros).

Esto solo funciona en modo de 32 bits. Eso está bien ya que los programadores reales codifican el tamaño de la palabra de todos modos.

#include <stdio.h>
#include <stdint.h>
/*
int fac(int x) {
    if (x < 1) return 1; else return x * fac(x - 1);
}

int fib(int x) {
    if (x < 2) return x; else return fib(x - 1) + fib(x - 2);
}

int main(void) {
    int a = fib(10), b = fac(10);
    printf("%d %d\n", a, b);
    return 0;
}
*/

typedef union REG {
    intptr_t i; int _i; void * v; union REG * r;
} REG;

#define LPAREN (
#define RPAREN )
#define MACRO(N) ); N##_MACRO LPAREN

#define push MACRO(PUSH)
#define pop  MACRO(POP)
#define mov  MACRO(MOV)
#define sub  MACRO(SUB)
#define add  MACRO(ADD)
#define imul MACRO(IMUL)
#define cmp  MACRO(CMP)
#define jge  MACRO(JGE)
#define jmp  MACRO(JMP)
#define call MACRO(CALL)
#define ret  MACRO(RET) _
#define label MACRO(LABEL)

#define NO_OP(X) 

#define PUSH_MACRO(VAL) *(esp -= 4) = (REG)(VAL)
#define POP_MACRO(DST) (DST) = (typeof(DST))(esp->i); esp += 4
#define MOV_MACRO(VAL, DST) (DST) = (typeof(DST))((REG)VAL).i;
#define SUB_MACRO(VAL, DST) CMP_MACRO(VAL, DST); \
    (DST) = (typeof(DST))(((REG)DST).i - ((REG)VAL).i)
#define ADD_MACRO(VAL, DST) DST = (typeof(DST))(((REG)DST).i + ((REG)VAL).i); \
    ZF = ((REG)DST).i == 0; OF = 0; SF = ((REG)DST).i < 0
#define IMUL_MACRO(VAL, DST) DST = (typeof(DST))(((REG)DST).i * ((REG)VAL).i); \
    ZF = ((REG)DST).i == 0; OF = 0; SF = ((REG)DST).i < 0
#define CMP_MACRO(L, R) CMP_MACRO_(((REG)L).i, ((REG)R).i)
#define CMP_MACRO_(L, R) (OF = 0, ZF = L == R, SF = (R - L) < 0)
#define JGE_MACRO(TGT) if (SF == OF) { goto TGT; } else {}
#define JMP_MACRO(TGT) goto TGT;
#define CALL_MACRO(PROC) CALL_MACRO_(PROC, __COUNTER__)
#define CALL_MACRO_(PROC, CTR) PUSH_MACRO(CTR - STARTIP); \
    goto PROC; case CTR - STARTIP:
#define RET_MACRO(_) eip = esp->i; esp += 4; if (eip) { continue; } else { goto *finalreturn; }
#define LABEL_MACRO(NAME) NAME

#define MY_ASM(X) do { const int STARTIP = __COUNTER__; \
    switch(eip) { case 0: MY_ASM_1 X } } while (1);
#define MY_ASM_1(X) MY_ASM_2(NO_OP LPAREN 0 X RPAREN;)
#define MY_ASM_2(X) X

#define CAT(L, R) _CAT(L, R)
#define _CAT(L, R) L##R

#define callASM(F) callASM_(F, CAT(_TMP_, __COUNTER__))
#define callASM_(F, LABEL) (({ PUSH_MACRO(0); stackbase = esp; finalreturn = &&LABEL; \
    goto F; LABEL:; }), (intptr_t)eax)


const int STACKSIZE = 4096;
REG callstack[STACKSIZE], * stackbase;
REG * eax, * ecx, * edx, * ebx, * esi, * edi, * esp, * ebp;
int SF, ZF, OF, eip; void * finalreturn;

int main(void) {
    eax = ecx = edx = ebx = esi = edi = esp = ebp = &callstack[STACKSIZE - 1];
    eip = 0;
    finalreturn = &&TOP; TOP:

    PUSH_MACRO(10);
    int a = callASM(_fac);
    PUSH_MACRO(10);
    int b = callASM(_fib);

    printf("%d %d\n", a, b);
    return 0;


    MY_ASM((
    label _fac:                                   // @fac
        push ebp
        mov esp, ebp
        sub 24, esp
        mov 8[ebp], eax
        mov eax, (-8)[ebp]
        cmp 1, (-8)[ebp]
        jge LBB0_2
        mov 1, (-4)[ebp]
        jmp LBB0_3
    label LBB0_2:
        mov (-8)[ebp], eax
        mov (-8)[ebp], ecx
        sub 1, ecx
        mov ecx, *esp
        mov eax, (-12)[ebp]         // 4-byte Spill
        call _fac
        mov (-12)[ebp], ecx         // 4-byte Reload
        imul eax, ecx
        mov ecx, (-4)[ebp]
    label LBB0_3:
        mov (-4)[ebp], eax
        add 24, esp
        pop ebp
        ret

    label _fib:                                   // @fib
        push ebp
        mov esp, ebp
        sub 24, esp
        mov 8[ebp], eax
        mov eax, (-8)[ebp]
        cmp 2, (-8)[ebp]
        jge LBB1_2
        mov (-8)[ebp], eax
        mov eax, (-4)[ebp]
        jmp LBB1_3
    label LBB1_2:
        mov (-8)[ebp], eax
        sub 1, eax
        mov eax, *esp
        call _fib
        mov (-8)[ebp], ecx
        sub 2, ecx
        mov ecx, *esp
        mov eax, (-12)[ebp]         // 4-byte Spill
        call _fib
        mov (-12)[ebp], ecx         // 4-byte Reload
        add eax, ecx
        mov ecx, (-4)[ebp]
    label LBB1_3:
        mov (-4)[ebp], eax
        add 24, esp
        pop ebp
        ret
    ))
}

Solo mira todos esos moldes. Casts significa que soy un programador más real que el compilador, ¿verdad?

Leushenko
fuente
8
+1, eso es ... retorcido. ;) Me gusta mucho cómo te manejaste call, en particular.
Ilmari Karonen
2
Guau. Ese es un gran trabajo.
Jack Aidley
Tenía un ensamblador para el C64 que funcionaba así. Agregó palabras clave BÁSICAS para todas las instrucciones 6510 y recuerdo que lo envolvió for pass=1:3...next. Ejecutándolo en el intérprete BASIC lo ensambló.
Ben Jackson
55
Esto es pura poesía.
Nicu Stiurca
1
Este es un hombre duro, el compilador está asombrado.
interconexiones están hechas de catz
102

Inglés en C

#include <stdio.h>
#define This
#define program     int main() {
#define aims
#define to
#define output      printf(
#define some
#define example
#define text(a)     #a
#define the
#define screen      "\n");
#define it          
#define also
#define will
#define calculate   ;int a = 
#define result
#define of
#define and
#define print       ; printf("%d\n", a);
#define seriously   return 0; }

This program aims to output some example text (Hello) to the screen;
it also will calculate the result of 3 + 4 and print the result; seriously

¿Alguna idea para eliminar el ;?

urzeit
fuente
18
En serio, chicos.
Kyle Strand
2
¿Por qué definir thedos veces?
Joshua Taylor
16
más
vale
20
Ahora conviértalo en un haiku.
Nicu Stiurca
1
Can you#define . ;
mbomb007
74

Brainfuck en JavaScript

¡Javascript es un lenguaje difícil! Usemos Brainfuck, un lenguaje más comprensible: o)

eval(

//write your easy code below

"++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."

//end of easy code

.replace(/\]/g,'}')
.replace(/\[/g,'while(a[i]){')
.replace(/\+/g,'a[i]++;')
.replace(/-/g,'a[i]--;')
.replace(/>/g,'i++;')
.replace(/</g,'i--;')
.replace(/\./g,'o+=String.fromCharCode(a[i]);')
.replace(/,/g,'a[i]=u.charCodeAt(j++);')
.replace(/^/,'var a=new Array(1000).join(\'0\').split(\'\'),i=500,o=\'\',u=prompt(\'Enter input if needed\'),j=0;')
.replace(/$/,'alert(o)')
)

Supongo que escribí un intérprete de brainfuck en javascript.

El ejemplo anterior simplemente emite Hello World!e ignora la entrada (sin ,símbolo).
¡Pero eso también funciona con las entradas! Por ejemplo, intente ,+>,+>,+>,+<<<.>.>.>.y escriba golfen el cuadro de diálogo. Superará los siguientes caracteres en la tabla ASCII:hpmg

EDITAR : breve explicación para las personas que no saben brainfuck.
Imagine una matriz infinita de enteros ainicializados a cero en todas partes, un puntero en un elemento de esta matriz iy una entrada del usuario u.
Brainfuck es realmente fácil de aprender pero difícil de escribir:

  • + incrementos al valor actual: a[i]++
  • - lo decrementa: a[i]--
  • > hace que el puntero señale el siguiente elemento: i++
  • < el anterior : i--
  • [y ]define un ciclo que se rompe cuando el valor actual es cero:while (a[i]) { ... }
  • . imprime el elemento actual: String.fromCharCode(a[i])
  • , establece el elemento actual con la entrada del usuario: u.charCodeAt(...)
Michael M.
fuente
22
+1 por el humor al afirmar que brainfuck es más comprensible que JavaScript.
Agi Hammerthief
¿Estás seguro de que los personajes de Brainfuck dentro de las replacedeclaraciones no afectan el programa?
Fraxtil
3
@fra Este archivo no es un programa brainfuck, es un programa javascript que contiene un programa brainfuck que se convierte a javascript en tiempo de ejecución.
undergroundmonorail
3
Bueno, --imás rápido que i--? Parece falso desde hace años: jsperf.com/decrementgolf .
Michael M.
44
Esto no solo es una presentación muy creativa al concurso, sino que también explica la sintaxis de brainfuck con mucha claridad. ¡+10 si pudiera!
SebastianH
74

Creo que el brillante Lennart Augustsson ya ha ganado esto dos veces.

Primero, aquí hay un ejemplo de su implementación de "hackeo de fin de semana" de BASIC como un DSL monárquico de Haskell, de 2009:

import BASIC

main = runBASIC' $ do

    10 LET I =: 1
    20 LET S =: 0
    30 LET S =: S + 1/I
    40 LET I =: I + 1
    50 IF I <> 100000000 THEN 30
    60 PRINT "Almost infinity is"
    70 PRINT S
    80 END

Funciona al sobrecargar el tipo de número. Los números de línea son realmente funciones que aceptan argumentos. El resto de la línea son argumentos de la función. La función devuelve una representación del Árbol de sintaxis abstracta para que el intérprete BASIC vaya a trabajar.

También te recomiendo que eches un vistazo a la entrada de Augustsson en el Concurso Internacional C Ofuscado de 2006, en el que logró meterse en 4k:

  • Un intérprete de código de bytes, escrito en un subconjunto de C (que él llama C ofuscado).
  • Un compilador C -> bytecode ofuscado , escrito en bytecode.

Pueden compartir el mismo archivo porque el byetecode se coloca dentro de los comentarios C.

Han pasado algunos años desde que seguí el trabajo de Augustsson, por lo que puede haber otras cosas brillantes que se le ocurran desde entonces ...

revs Pitarou
fuente
2
Es Augustsson, no Augustssen.
Hans Lundmark
@HansLundmark Gracias. Arreglado.
Pitarou
71

PHP y Javascript

Este es un políglota:

Puede ejecutar este código en ambos idiomas:

if("\0"=='\0')
{
    function printf(){
        $b=Array();
        $a=$b['slice']['call'](arguments);
        $a=$a['join']('');
        console.log($a);
        return $a.length;
    };

    function strtoupper($s){return $s['toUpperCase']();}

    function count($a){return $a['length'];}
}

printf('this is cool!');

$c=Array('a','b','c','d');

for($i=0,$l=count($c);$i<$l;++$i)printf("\n",strtoupper($c[$i]));

El truco aquí es que Javascript usa secuencias de escape en cadenas que comienzan con 'y ".
Por otro lado, PHP solo usa secuencias de escape en cadenas que comienzan con "y <<<.

Luego, declaramos la función printf, que es similar printpero genera una cadena formateada en PHP.

PHP requiere que los vars comiencen $, mientras que Javascript simplemente lo permite.

Ismael Miguel
fuente
Nadie lo está usando Array(…)en JS, y está claramente array(…)en PHP. […]sería mucho mejor;)!
Blackhole
12
No me importa si la gente usa Array()JS o no: me importa que tenga un políglota VERDADERO . Estoy cometiendo uno de los peores crímenes de JS con este código, pero todo lo que quiero es que se ejecute y haga exactamente lo mismo en ambos, pero que parezca JS y PHP al mismo tiempo.
Ismael Miguel
Y por cierto, [...]no es válido en PHP <5.4.0, lo cual es malo ....... Si lanzo esto en PHP 4, 5 o Javascript, espero que funcione, en lugar de dar errores de sintaxis en todas partes.
Ismael Miguel
2
Si desea que su código se parezca a JS, debe usarlo […], lo que parece bastante estándar en PHP y, por lo tanto, está bien para su objetivo. Y por cierto, PHP <5.4? Hora de actualizar, chico ...
Blackhole
8
La compatibilidad es más importante que las "miradas". Y Arrayes el nombre CORRECTO del constructor del objeto Array. Básicamente, usar []es lo mismo que Array(). No veo nada malo con eso. Pero tengo una pregunta simple: ¿funciona? (por cierto, tengo que usar php 5.3.28 en el trabajo.)
Ismael Miguel
55

Brainfuck en JS

[][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[
!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[
+!+[]]]]][([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(
![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!
![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+
[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]
]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[
]+!+[]+!+[]+!+[]]]]+([][[]]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+[]+!+[]]]]+(!!
[]+[])[+[[+[]]]]+(!![]+[])[+[[+!+[]]]]+([][[]]+[])[+[[+[]]]]+([][(![]+[])[+[[
+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!
![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+
[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[
[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!!
[]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]+!+[]
+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]((![]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+
[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]+(!![]+[])[+[[+[]]]
]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[
+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[
+[[+!+[]]]]]+[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+[+!+[]]+([][(![]+[]
)[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]
]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+
[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]]])()
Clyde Lobo
fuente
12
No veo ninguna mierda aquí. Ni siquiera un solo personaje><,.-
Michael M.
8
@ Michael: ¿Quién dijo que no es un programa que hace un bucle infinito?
Konrad Borowski
19
es esto JSF * ck?
8
¿Cómo demonios hace eso ?
nandhp
44
Oo Alguien finalmente hizo esto. Pasé un tiempo tratando de descubrir cómo escribir un programa JS usando solo los caracteres +! [] () Pero nunca pude entenderlo. Necesito analizar esto cuando tengo tiempo ...
Matti Virkkunen
54

Este es uno de los ganadores de IOCCC 2005 , un programa C que, excepto por ese grupo de definiciones, se parece a un programa java:

/*
 * Sun's Java is often touted as being "portable", even though my code won't
 * suddenly become uber-portable if it's in Java. Truth is, Java's one of
 * the most ugly, slow, and straitjacketed languages ever. It's popular
 * mainly because people hear the word "portable" and go "ewww".
 *
 * This program, then, is dedicated to bringing about the death of Java. We
 * good coders have been oppressed for too long by the lame language
 * decisions of pointy-haired bosses and academics who should know better. 
 * It's time we stand up against this junk, and bring back the fun in
 * programming! Viva La Revolution!
 */

#define aSet c
#define BufferedReader(x)1
#define byte Y[I][_^1]?do(:):_&1?do(.):do(`):8;++y;}
#define class int N=0,_,O=328,l=192,y=4,Y[80][64]={0},I;struct
#define do(c)a(#c "\b")
#define err c,c
#define getAllStrings(x));q()
#define if(x)b(#x)
#define IOException
#define line c
#define main(a)b(char*x){write(1,"\033[",2),null}main()
#define new
#define null a(x);}a(char*x){write(1,x,strlen(x));try;try;try;try;
#define out c,c
#define println(x)c
#define private int d(int
#define public short c;}c;typedef int BufferedReader;char*F="JF>:>FB;;BII";
#define return {return
#define static f(x){N=(N+x)%6,y--?f(0),f(1),f(4),f(1):++Y[(I=O+N[F]-66)
#define String
#define System c
#define this if(D):1,O=I,I/=16,l<_/32?if(B):l>_/32?if(A):2,l=_,_/=16,byte
#define throws
#define toArray(x)c
#define try for(;--c.c;)
#define void /16][(_=l+N[6+F]-66)/16]?O/=16,l/=32,O<I/16?if(C):O>I/16?this
#define while(k)if(2J),if(7;21H),f(0),f(4),f(4),if(H),/*

import java.io.*;
import java.util.*;

/**
 * A lame Java program.
 * @author  J. Random Worker
 */
class LameJavaApp
{

    /** The infamous Long-Winded Signature From Hell. */
    public static void main(String[] args)
        throws IOException
    {
        /* Don't get me started on this. */
        BufferedReader reader =
            new BufferedReader(new FileReader(args[0]));

        /* What, this long incantation just to print a string? */
        System.err.println("Hello world!");

        /* At least this is sane. */
        String line;
        while ((line = reader.readLine()) != null)
            System.out.println(line.length());
    }

    /**
     * Method with a needlessly long name.
     * @param   aSet        a set (!)
     */
    private String[] getAllStrings(Set<String> aSet)
    {
        /*
         * This dance is needed even in J2SE 5, which has type
         * templates. It was worse before that.
         */
        return aSet.toArray(new String[0]);
    }

}
Victor
fuente
3
Verbosidad en su máxima expresión.
qwr
39

C ++ en C

OK, entonces eres un programador de C ++, pero ¿estás obligado a usar C? No hay problema, solo tiene que escribir algunos encabezados suplementarios que faltan en C. Por ejemplo, aquí hay un programa válido de Hello World en C:

En el archivo de encabezado suplementario iostream, escriba:

#include <stdio.h>

#define using volatile int
#define namespace message
#define std = 0
#define message(x) printf("%s\n",x)
#define cout 0
#define endl 0

En archivo string, escribe

#define string

En el archivo helloworld.c(su código C real), escriba

#include <iostream>
#include <string>

using namespace std;

int main()
{
  string message("Hello world");
  cout << message << endl;
  return 0;
}

Y al compilar helloworld.ccon un compilador de C, indique al compilador que también busque <...>los archivos de encabezado donde haya almacenado los archivos iostreamy string, por ejemplo, si está compilando con gcc y coloca los archivos iostreamy stringen el directorio actual, compile con

gcc helloworld.c -o helloworld -I.

Nota: El volatileencabezado in iostreamestá ahí para permitir una compilación sin advertencia incluso al nivel máximo de advertencia (se considera que una lectura de una variable volátil tiene efecto).

celtschk
fuente
3
Esto es un poco de código trolling, ¿no es así?
Sr. Lister
Bueno, el programa hace exactamente lo que parece hacer, ¿no?
celtschk
8
Mucho más divertido e impresionante de esta manera que C en C ++.
Kyle Strand
¿Qué tipo de compilador advierte si no lo usa volatileaquí, y qué tipo de advertencia?
R. Martinho Fernandes
1
@KyleStrand Pero el "C en C ++" está más en sintonía con la cita en la pregunta. Los programadores reales programan en C, incluso si tienen un compilador de C ++.
Sr. Lister
36

CQL - Lenguaje de consulta con cafeína

(o "SQL en cafeína")

Esto puede haber sido algo demasiado ambicioso. Aquí hay un intento de escribir código declarativo SQL (ish) en CoffeeScript . Esto requiere la función Proxy ECMAScript 6 . Puedes probarlo en nodo con --harmony-proxies.

Vamos a configurar una plantilla para definir proxies. (Tomado del comentario de Benvie sobre este tema )

forward = (->
  _slice  = Array.prototype.slice
  _bind   = Function.prototype.bind
  _apply  = Function.prototype.apply
  _hasOwn = Object.prototype.hasOwnProperty

  Forwarder = (target) ->
    @target = target
    this

  Forwarder.prototype =
    getOwnPropertyNames: -> Object.getOwnPropertyNames(@target)
    keys: -> Object.keys(@target)
    enumerate: ->
      i = 0
      keys = []
      for value of @target
        keys[i++] = value
      keys
    getPropertyDescriptor: (key) ->
      o = @target;
      while o
        desc = Object.getOwnPropertyDescriptor o, key
        if desc
          desc.configurable = true;
          return desc;

        o = Object.getPrototypeOf o
    getOwnPropertyDescriptor: (key) ->
      desc = Object.getOwnPropertyDescriptor @target, key
      if desc
        desc.configurable = true
      desc
    defineProperty: (key, desc) -> Object.defineProperty @target, key, desc
    get: (receiver, key) -> @target[key]
    set: (receiver, key, value) ->
      @target[key] = value;
      true
    has: (key) -> key of @target
    hasOwn: (key) -> _hasOwn.call @target, key
    delete: (key) ->
      delete @target[key]
      true
    apply: (receiver, args) -> _apply.call @target, receiver, args
    construct: (args) -> new (_bind.apply @target, [null].concat args);

  forward = (target, overrides) ->
    handler = new Forwarder target;
    for k of Object overrides
      handler[k] = overrides[k]

    if typeof target is 'function'
      return Proxy.createFunction handler,
                                  -> handler.apply this, _slice.call arguments,
                                  -> handler.construct _slice.call arguments
    else
      return Proxy.create handler, Object.getPrototypeOf Object target

  forward
)();

Ahora defina un objeto proxy y algunas variables y funciones globales sospechosas:

sql = forward {
  tables: {}

  finalize: ->
    if typeof @activeRows isnt 'function'
      @result = []
      for row in @activeRows
        @result.push (val for val, i in row when @activeTable.columns[i] in @activeColumns)
    delete @activeRows
    delete @activeColumns
    delete @activeTable

  run: (q) ->
    q.call(this)
    @finalize()
    result = @result
    delete @result
    if typeof result isnt 'function' then console.log result
    return result
}, {
  get: (o,name) ->
    if name of @target
      return @target[name];
    (args...) -> {
      name
      args
    }
}

int = Number
varchar = (l) -> String

TABLE = (x) -> x
INTO = (x) -> x
CREATE = (tableData) ->
  name = tableData.name
  table =
    columns: []
  column = tableData.args[0]
  table[column.name] = []
  table.columns.push(column.name)
  while column = column.args[1]
    table[column.name] = []
    table.columns.push(column.name)

  sql.tables[name] = table

  sql.result = "Created table '#{name}'"

INSERT = (table) -> sql.activeTable = sql.tables[table().name]
VALUES = (rows...) ->
  for row in rows
    for val, i in row
      column = sql.activeTable.columns[i]
      sql.activeTable[column].push val

  sql.result = "Inserted #{rows.length} rows"

FROM = (table) ->
  sql.activeTable = sql.tables[table().name]
SELECT = (columns...) ->
  sql.activeColumns = []
  for col in columns
    if typeof col is 'function'
      col = col()

    sql.activeColumns.push col.name

  sql.activeRows = []
  for val in sql.activeTable[sql.activeTable.columns[0]]
    sql.activeRows.push []

  for col in sql.activeTable.columns
    for val, i in sql.activeTable[col]
      sql.activeRows[i].push val

IN = (list) -> { op: 'in', list }
WHERE = (column) ->
  i = sql.activeTable.columns.indexOf(column.name)
  if column.args[0].op is 'in'
    list = column.args[0].list
    sql.activeRows = (row for row in sql.activeRows when row[i] in list)
  else
    console.log 'Not supported!'

ASC = 'asc'
DESC = 'desc'
BY = (x) -> x
ORDER = (column) ->
  i = sql.activeTable.columns.indexOf(column.name)
  order = if column.args[0] is sql.ASC then 1 else -1
  sql.activeRows.sort (a,b) ->
    if a[i] < b[i]
      return -order
    else if a[i] > b[i]
      return order
    else
      return 0

Bueno, eso fue una gran cantidad de configuración! Pero ahora podemos hacer lo siguiente (entrada / salida en un estilo de consola):

> sql.run ->
    CREATE TABLE @books(
      @title varchar(255),
      @author varchar(255),
      @year int
    );

Create Table 'books'

> sql.run ->
    INSERT INTO @books
    VALUES ['The C++ Programming Language', 'Bjarne Stroustrup', 1985],
           ['Effective C++', 'Scott Meyers', 1992],
           ['Exceptional C++', 'Herb Sutter', 2000],
           ['Effective STL', 'Scott Meyers', 2001];

Inserted 4 rows

> sql.run ->
    SELECT @title, @year FROM @books
    WHERE @author IN ['Bjarne Stroustrup', 'Scott Meyers']
    ORDER BY @year DESC;

[ [ 'Effective STL', 2001 ],
  [ 'Effective C++', 1992 ],
  [ 'The C++ Programming Language', 1985 ] ]

No es un políglota real, pero ese no es realmente el punto. Sé que @se usa para variables en SQL, pero necesito todas las @s para los nombres de columna y tabla porque no he encontrado una forma de proxy del objeto global (y no me sorprendería si realmente no es posible, y para una buena razón).

También cambié algunos paréntesis entre paréntesis (en particular después VALUESy IN). Desafortunadamente, lo que no pude entender en absoluto es una forma de permitir condicionales normales como year > 2000, porque evaluarían a un booleano de inmediato.

Aún así, esto se parece mucho a SQL y definitivamente es más declarativo que imperativo / funcional / orientado a objetos, por lo que debería calificar bien para la pregunta. De hecho, estoy pensando que si pulí un poco el código y admití algunas características más, este podría ser un módulo útil de CoffeeScript.

De todos modos, esto fue divertido! :)

Para aquellos que no están demasiado familiarizados con CoffeeScript, las consultas SQL se compilan en el siguiente JavaScript:

sql.run(function() {
  return CREATE(
    TABLE(
      this.books(
        this.title(varchar(255), 
        this.author(varchar(255), 
        this.year(int)))
      )
    )
  );
});

sql.run(function() {
  INSERT(INTO(this.books));
  return VALUES([...], ['Effective C++', 'Scott Meyers', 1992], [...], [...]);
});

sql.run(function() {
  SELECT(this.title, this.year(FROM(this.books)));
  WHERE(this.author(IN(['Bjarne Stroustrup', 'Scott Meyers'])));
  return ORDER(BY(this.year(thisESC)));
});
Martin Ender
fuente
Eso es bastante configuración, pero se ve bien. No soy un programador de CoffeeScript, pero se ve muy bien. El @en SQL se utiliza para las variables de sesión.
Ismael Miguel
Decidí hacer que las palabras clave sean globales ahora. Ahora solo hay @s para los nombres de columna y tabla.
Martin Ender
¡Ahora se parece mucho a SQL! ¡Hiciste un buen trabajo con este!
Ismael Miguel
1
No me importa mucho el café, pero esto es increíble.
KRyan
2
@tac gracias, pero no, simplemente lo pirateé para este desafío. Curiosa coincidencia: rehacer esto de una manera limpia y ponerlo en GitHub estaba en mi lista de proyectos de codificación potenciales / a largo plazo hasta que lo eliminé esta mañana.
Martin Ender
27

Visual Basic 6 (en JavaScript)

'; Main sub-routine \
'; function Main() { ' \
Sub Main() '
    ' Do not throw any errors... \
    On Error Resume Next '; MsgBox = alert

    ' Show a message box... \
    MsgBox(1 / 0) '

    ' Show errors again... \
    On Error GoTo 0 '

    ' Show another message box... '
    MsgBox("Hello")
    ' ' } ' \
End Sub '

Main()

También funciona en VBScript.

Cepillo de dientes
fuente
1
Inteligente. Ni siquiera necesita la mayoría de los puntos y comas.
js1568
@ js1568 ¡Gracias! Ahora he eliminado los punto y coma que no son necesarios.
Cepillo de dientes
20

F # en C ++

Bastante poco imaginativo y desagradable abuso del preprocesador. Pensé que sería divertido alterar C ++ para que parezca un lenguaje completamente diferente en lugar de usar algunos alias para que se vea como Java o PHP. Realmente no espero que esto obtenga un montón de votos a favor, es una entrada solo por diversión.

#define let int
#define args ( int __, char* args[] ) { int ___ 
#define println printf(
#define exit "\n" ); return 0; }
#include <stdio.h>

let main args =
    println "F# is better than C++"
    exit

Probarlo aquí .

Lamentablemente, escribir algo en STDOUT es todo lo que puede hacer, aunque estoy seguro de que si alguien le arroja suficiente brujería, podría hacer que haga más.

Tony Ellis
fuente
2
Para que la última línea funcione en F #, tendría que ser exit 0o simplemente 0.
Jwosty
20

Python y ... nadie lo adivinará (editar: dc)

Aquí hay un código válido de Python, pero en realidad el programa está escrito en un lenguaje muy diferente:

# Initialize systems 1 and 2
# frame 1, divergency speed and divergency latency
f1ds, f1dl, z1 = [2,2,0]
# frame 2, divergency speed and divergency latency
f2ds, f2dl, z2 = [4,4,1]

# Set the most relevant value of ax (detected by low-energy collision)
ax = 42.424242

# Initialize list of successive energy states
s = [17.98167, 21.1621, 34.1217218, 57.917182]

# Most common value for nz parameter
# TODO: check if value from the article of A. Einstein is better
nz = 10

if z2>nz or ax in s:
  ax += 6
  f1ds = 8
  f2ds = 16
  z1 = 4
  z2 = 9

f1dl += z1
f2dl += z2

# main loop, iterate over all energy states
# Warning: hit Ctrl-C if nuclear explosion occurs and adjust either z or nz
for k in s:
  z = nz + k
  f1dl = f1ds + f2dl * z - z1 + 3.14
  f2dl = f2ds + f1dl * z - z2 + 10
  if k > 10 or z-2 in s:
    nz += 0xac  # hexadecimal coefficient found in famous article by E. Fermi

El código se ejecuta en ambos idiomas sin error.

La combinación es muy loca; Me encantaría esperar uno o dos días antes de decir cuál es el otro idioma; por favor deje comentarios para adivinar.

editar: El idioma era el lenguaje basado en pila de DC. Usted puede ver aquí palabras clave conocidas como for, if, or, in, pero sólo importa las letras! El ,que no tiene significado en CC se convierte en un registro porque la primera vez que aparece es después de la letra s(lo mismo para :).

Thomas Baruchel
fuente
1
A menos que el código haga lo mismo en ambos idiomas, supongo que un lenguaje como Befunge podría hacer el truco.
Thomas Eding
OK, edito el código para poner el idioma que realmente elegí.
Thomas Baruchel
18

C ++ le permite escribir código similar a lisp, con la biblioteca InteLib:

(L|DEFUN, ISOMORPHIC, (L|TREE1, TREE2),
   (L|COND, 
     (L|(L|ATOM, TREE1), (L|ATOM, TREE2)),
     (L|(L|ATOM, TREE2), NIL),
     (L|T, (L|AND,
       (L|ISOMORPHIC, (L|CAR, TREE1), 
                      (L|CAR, TREE2)),
       (L|ISOMORPHIC, (L|CDR, TREE1), 
                      (L|CDR, TREE2))
 )))).Evaluate();

cf. http://www.informatimago.com/articles/life-saver.html

informatimago
fuente
44
¡Bienvenidos! Pedimos a los usuarios que marquen sus publicaciones como Community Wiki cuando la respuesta no es su propio trabajo. (Y da la atribución adecuada, pero ya lo hiciste, ¡así que gracias!)
Jonathan Van Matre
Original o no, tienes mi voto :)
itsjeyd
15

C # en espacios en blanco

Bien, primero intente con uno de estos, así que veamos cómo va. 

using System; //very important  

namespace ConsoleApplication1  //namespace: name whatever you want      
{ 
 //start    
 class  Program  //class name:  also anything    
    {
    //main function 
    static void Main(string[] args) {
        for(int i=0;i<10;i++)   writeOutput(i); 
    } //end main    
    static void writeOutput(int i) { Console.WriteLine(i); }    //display output    


    } //class ends here         

}  //close namespace:   also very important     





//yay!

Y en caso de que el formato se volviera complicado por tener que poner cuatro espacios en el frente de cada línea, aquí está nuevamente con. para espacio y # para pestaña:

using.System;.//very.important#

namespace.ConsoleApplication1..//namespace:#name.whatever.you.want##
{.
.//start#
.class#Program..//class.name:#also.anything#.
#{
....//main.function#
#static.void.Main(string[].args).{
....#for(int.i=0;i<10;i++)#writeOutput(i);#
#}.//end.main#
#static.void.writeOutput(int#i).{.Console.WriteLine(i);.}#//display.output#

.
.#}.//class.ends.here.##

}..//close.namespace:#also.very.important#.#
.




//yay!
Roger
fuente
12

HTML y CSS

No son lenguajes de programación, pero ... este documento es HTML y CSS válido :

<!-- p{color:red} /* -->
<!Doctype html>
<title>This is HTML and CSS</title>
<p>Hi!</p>
<!-- */ -->
<!-- p{color:red} /* -->
<!Doctype html>
<title>This is HTML and CSS</title>
<p>Hi!</p>
<!-- */ -->

Esto funciona porque los comentarios HTML están permitidos en las hojas de estilo por razones históricas. Ah, y cada documento HTML válido también es un programa PHP válido, por lo que también es PHP . :)

fuxia
fuente
2
Eso es bastante divertido y todo, pero esto no es realmente un desafío políglota .
Martin Ender
Dado que CSS podría considerarse como completo , esta puede ser una respuesta válida.
Adam Davis
2
HTML y CSS no son lenguajes de programación :)
Jet
9

C en Scala

La capa de puente emula una era más romántica cuando las cadenas todavía eran matrices de bytes con terminación nula. 

// Scala is a dynamic language
import scala.language.{ dynamics, postfixOps }

val self = this

val argc = args.length
val argv = args.map(_.getBytes)

type char = Array[Byte]
object char extends Dynamic {
  // This program uses expanded memory
  val buffers = new scala.collection.mutable.LinkedHashMap[String, char]

  // Malloc char buffer
  def applyDynamic(name: String)(length: Int) =
    buffers(name) = new Array(length)

  def **(argv: Array[Array[Byte]]) = argv
}

object & extends Dynamic {
  // dereference char pointer
  def selectDynamic(name: String) = char.buffers(name)
}

def printf(format: String, buffers: char*) =
  println(
    (format /: buffers){ case (msg, buffer) =>
      // Read string until \0 terminator
      val value = new String(buffer.takeWhile(0 !=))
      // Replace next %s token
      msg.replaceFirst("%s", value)
    }
  )

def scanf(format: String, buffers: char*) =
  buffers foreach { buffer =>
    val line = Console.readLine()
    // Write string to char* buffer
    line.getBytes(0, line.length, buffer, 0)
    // Remember to always null terminate your strings!
    buffer(line.length) = 0
  }

val PATH_MAX = 4096

implicit class Argumenter(args: Pair[_, _]) {
  def apply[T](f: => T) = f
}

object int {
  // Passthrough
  def main[T](f: => T) = f
  def argc = self.argc
}

// terminates the string after the first character
// investigate switching to "xor eax, eax" instead of having a hardcoded 0
// might save 3 bytes and valuable CPU time with this trick
val initialize = (_: char)(1) = 0

def exit(value: Int) = sys.exit(value)
// ---HOMEWORK-ASSIGNMENT-START---

int main(int argc, char **argv) {
  if (argc != 0) {
    printf("This program does not take parameters!");
    exit(1);
  }

  // I've copy pasted this code from somewhere
  // Code reuse is essential if we want to be DRY
  char first(PATH_MAX + 1);
  char last(PATH_MAX + 1);

  printf("Enter your first and last name:\n");
  scanf("%s%s", &first, &last);

  // Still learning references, do I need these here?
  // I've performed benchmarks on printf and I think it's faster this way
  printf("Your full name is %s %s", &first, &last);

  initialize(&first);
  printf("Your signature is %s. %s", &first, &last);

  exit(0);
}
melezov
fuente
"This program does not take parameters!"te engañé
Erik the Outgolfer
8

sed y APL

Mi jefe quiere que escriba scripts de sed, pero prefiero escribir APL todo el día. Sin embargo, está muy contento con mi trabajo porque tales scripts se ejecutan perfectamente con su versión de sed:

i ← g ← 42
a ← d ← 10
s/s←2⊤42/s←2⊤43/g
s/s[01]*1/s⊣1/g
g

Puedes probarlo en mi nuevo sitio web con este enlace permanente . Es una versión compilada a javascript de GNU APL. El lanzamiento final será más tarde con el lanzamiento oficial de GNU APL, v. 1.3, pero puedes usarlo perfectamente para tus enlaces permanentes si disfrutas de GNU APL.

Thomas Baruchel
fuente
7

C en Haskell

import Foreign.C.String
import Foreign.C.Types
import Foreign.Marshal.Array
import Foreign.Ptr
import System.Environment
import System.Exit

-- The meat of the program

cmain :: (CInt, Ptr (Ptr CChar)) -> IO CInt
cmain(argc, argv) = do {
    putStr("hello, world\n");
    return 0;
}

-- Of course, the above function doesn't do anything unless we write a wrapper
-- around it.  This could have been done more simply, using higher-level library
-- functions, but where's the fun in that?

main :: IO ()
main = do {
    args <- getArgs;
    argPtrs <- sequence [do {
        argPtr <- mallocArray0(length(arg)) :: IO (Ptr CChar);
        pokeArray0(0)(argPtr)(map(castCharToCChar)(arg));
        return argPtr;
    } | arg <- args ];
    argv <- mallocArray(length(argPtrs)) :: IO (Ptr (Ptr CChar));
    pokeArray(argv)(argPtrs);

    exitCode <- cmain(fromIntegral(length(args)),argv);

    if (exitCode == 0) then do {
        exitWith(ExitSuccess);
    } else do {
        exitWith(ExitFailure(fromIntegral(exitCode)));
    };
}

Por supuesto, dado cmainque no hace nada con argco argv, el código de cálculo de argumentos no tiene ningún efecto, y dado que cmainsiempre devuelve 0, la rama "else" de la instrucción "if" está muerta. Pero la declaración "si" no hace nada de todos modos.

Todos los corchetes y puntos y comas son innecesarios, como lo son la mayoría de los paréntesis y algunas de las dopalabras clave. La declaración "if" podría haberse escrito como if exitCode == 0 then exitWith ExitSuccess else exitWith (ExitFailure (fromIntegral exitCode)).

Tanner Swett
fuente
7

C ++ en adelante

: #include ; : <iostream> ; : { ; : } ; : int ; : using ;
: namespace ; : std; ; : main() ; : cout ; : << ;
: "Hello,  ; : world!\n"; S" Hello, world!" type ; : return ; : 0; ;

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, world!\n";
}

No es la solución más flexible, pero funciona si se escribe exactamente como se muestra.

Miguel
fuente
7

Haskell en Java

("Vanilla" Java 7, no Java 8) (Sí, sé que el boxeo arruina el rendimiento; e incluso tratar de usar funciones de orden superior se vuelve muy detallado: D)

Java tiene una sintaxis muy rígida, por lo que en lugar de cambiar la sintaxis intenté hacer que el código sea semánticamente más similar al estilo Haskell.

Editar: aplicación de función parcial agregada.

import java.util.Iterator;

interface Function1<A, B> {
    A call(B arg);
}

interface Function2<A, B, C> {
    A call(B arg1, C arg2);
}

class Reduce<A> implements Function2<A, Function2<A, A, A>, Iterable<A>> {

    @Override
    public A call(Function2<A, A, A> arg1, Iterable<A> arg2) {
        final Iterator<A> i = arg2.iterator();
        A r = i.next();
        while (i.hasNext())
            r = arg1.call(r, i.next());
        return r;
    }
}

class Range implements Iterable<Integer> {

    private final int min;
    private final int max;

    public Range(int min, int max) {
        this.min = min;
        this.max = max;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = min;

            @Override
            public boolean hasNext() {
                return i <= max;
            }

            @Override
            public Integer next() {
                return i++;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }
}

public class Main {

    public static <A, B, C> Function1<A, C> applyPartial(final Function2<A, B, C> f, final B arg2) {
        return new Function1<A, C>() {
            @Override
            public A call(C arg) {
                return f.call(arg2, arg);
            }
        };
    }

    public static void main(String[] args) {

        final Function1<Integer, Iterable<Integer>> product = applyPartial(new Reduce<Integer>(), new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer arg1, Integer arg2) {
                return arg1 * arg2;
            }
        });

        final Function1<Integer, Integer> fact = new Function1<Integer, Integer>() {

            @Override
            public Integer call(Integer arg) {
                return product.call(new Range(1, arg));
            }
        };

        final Integer x = fact.call(6);

        System.out.println(x.toString());
    }
}

(Sí, todo lo que hace esta locura es computar 6!)

Sarge Borsch
fuente
6

COBOL en AWK

En el espíritu de la cita. AWK puro, sin adulterar, ya que puede ser escrito por un programador COBOL.

La tarea es contar los registros en un archivo. Esta versión de desarrollo inicial se cuenta para las pruebas. El archivo correcto se codificará más tarde cuando se libere de Unit Testing ...

Si pudiera obtener el resaltado de sintaxis para hacer verde fosforescente en negro, sería genial ...

Incluso obtuve los números de columna correctos en este caso, son siete espacios en blanco al comienzo de cada línea (nunca lo hice en awk antes) y rompiendo las declaraciones de letra larga en la columna 72.

   BEGIN { 
       PERFORM_000_INITIALISATION() 
       PERFORM_100_OPEN_FILES() 
       PERFORM_200_PROCESS_FILE() 
       PERFORM_300_CLOSE_FILES() 
       PERFORM_400_SHOW_THE_COUNTS() 
       exit 
   } 
   function PERFORM_000_INITIALISATION() { 
       INPUT_FILE_NAME = "COBOL.AWK" 
       RECORD_COUNT = 0 
   } 
   function PERFORM_100_OPEN_FILES() { 
   } 
   function PERFORM_200_PROCESS_FILE() { 
       PERFORM_210_PRIMING_READ() 
       PERFORM_220_PROCESS_INPUT_UNTIL_END() 
   } 
   function PERFORM_300_CLOSE_FILES() { 
   } 
   function PERFORM_400_SHOW_THE_COUNTS() { 
       print "COBOL.AWK: NUMBER OF RECORDS READ IS " RECORD_COUNT        
   } 
   function PERFORM_210_PRIMING_READ() { 
       PERFORM_900_READ_THE_FILE() 
       if ( FILE_STATUS < 0 ) { 
           print "COBOL.AWK ERR0001: INVALID FILE, HALTING, FILE N" \
                 "AME IS: " INPUT_FILE_NAME 
           exit 
           } 
       if ( FILE_STATUS == 0 ) { 
           print "COBOL.AWK ERR0002: NO RECORDS ON INPUT, HALTING," \
                 "FILE NAME IS: " INPUT_FILE_NAME 
           exit 
           } 
   } 
   function PERFORM_220_PROCESS_INPUT_UNTIL_END() {
       while ( FILE_STATUS != 0 ) { 
           INPUT_RECORD = $0 
           RECORD_COUNT = RECORD_COUNT + 1 
           PERFORM_900_READ_THE_FILE() 
           } 
   } 
   function PERFORM_900_READ_THE_FILE() { 
       FILE_STATUS = getline < INPUT_FILE_NAME 
   }
Bill Woodger
fuente
6

Brainfuck (o cualquier otra cosa) en Racket

El módulo flexible y el sistema macro de Racket le permiten implementar soporte de módulos para lenguajes completamente nuevos, tanto de dominio específico como de propósito general. Existe compatibilidad inmediata para Datalog y Algol 60 , por lo que los siguientes son programas válidos de Racket:

#lang datalog
edge(a, b). edge(b, c). edge(c, d). edge(d, a).
path(X, Y) :- edge(X, Y).
path(X, Y) :- edge(X, Z), path(Z, Y).
path(X, Y)?

#lang algol60
begin
  integer procedure SIGMA(x, i, n);
    value n;
    integer x, i, n;
  begin
    integer sum;
    sum := 0;
    for i := 1 step 1 until n do
      sum := sum + x;
    SIGMA := sum;
  end;
  integer q;
  printnln(SIGMA(q*2-1, q, 7));
end

También puede agregar soporte para otros idiomas: por ejemplo, vea la descripción de Danny Yoo sobre cómo implementar el soporte para Brainfuck, que permite programas Racket como:

#lang planet dyoo/bf
++++++[>++++++++++++<-]>.
>++++++++++[>++++++++++<-]>+.
+++++++..+++.>++++[>+++++++++++<-]>.
<+++[>----<-]>.<<<<<+++[>+++++<-]>.
>>.+++.------.--------.>>+.

Y dado que el soporte se agrega a nivel de módulo compilado, es posible vincular módulos escritos en diferentes idiomas o incrustar un fragmento de un idioma dentro de un módulo escrito en otro.

Uri Zarfaty
fuente
5

SML en Java

Todavía tengo un código antiguo desde que comencé a aprender Java e intenté usarlo en un estilo funcional. Ligeramente limpiado:

/**
 * Genericised ML-style list.
 */
public class FunctionalList<T> 
{
    private final T head;
    private final FunctionalList<T> tail;

    public FunctionalList(T x, FunctionalList<T> xs) {
        this.head = x;
        this.tail = xs;
    }

    public static <T> FunctionalList<T> cons(T x, FunctionalList<T> xs) {
        return new FunctionalList<T>(x, xs);
    }

    public static <T> T hd(FunctionalList<T> l) {
        return l.head;
    }

    public static <T> FunctionalList<T> tl(FunctionalList<T> l) {
        return l.tail;
    }

    public static int length(FunctionalList<?> l) {
        return len(l, 0);
    }

    private static int len(FunctionalList<?> l, int n) {
        return l == null ? n : len(tl(l), n + 1);
    }

    public static <T> FunctionalList<T> rev(FunctionalList<T> l) {
        return rev(l, null);
    }

    private static <T> FunctionalList<T> rev(FunctionalList<T> a, FunctionalList<T> b) {
        return a == null ? b : rev(tl(a), cons(hd(a), b));
    }

    public static <T> FunctionalList<T> append(FunctionalList<T> a, FunctionalList<T> b) {
        return a == null ? b : cons(hd(a), append(tl(a), b));
    }
}
Peter Taylor
fuente
5

Java en Perl

Puede contar como romper las reglas, pero no me importa. Obviamente, está destinado a parecerse al programa Java. Imprime 20 números de Fibonacci, en caso de que no sea obvio.

Requiere que se instale el módulo Inline :: Java .

use Inline Java => <<'JAVA';
/**
 * @author  Konrad Borowski <[email protected]>
 * @version 0.1.0
 */
class Fibonacci
{
    /**
     * Responsible for storing the number before last generated number.
     */
    private long beforeLastNumber = 0;

    /**
     * Responsible for storing the last generated number.
     */
    private long lastNumber = 1;

    /**
     * Receives the next Fibonacci number.
     * 
     * @return long integer that is the next Fibonacci number
      */
    public long next()
    {
        long temponaryLastNumber = lastNumber;
        lastNumber = beforeLastNumber + lastNumber;
        beforeLastNumber = temponaryLastNumber;
        return temponaryLastNumber;
    }

    /**
     * Outputs the Fibonacci number to standard output.
     */
    public void printFibonacci()
    {
        System.out.println(next());
    }

    /**
     * Outputs the Fibonacci number to standard output given number of
     * times.
     * 
     * @param times number of times to print fibonacci number
     */
    public void printFibonacciTimes(int times)
    {
        int i;
        for (i = 0; i < times; i++) {
            printFibonacci();
        }
    }

    /**
     * Constructor for Fibonacci object. Does nothing.
     */
    public Fibonacci()
    {
        // Do nothing.
    }
}
JAVA

###
 # The executable class that shows 20 Fibonacci numbers.
 ##
package OutputFibonacci
{
    ###
     # Shows 20 Fibonacci numbers. This method is public,
     # static, and returns void.
     ##
    sub main()
    {
        # In Perl, -> is object method separator, not a dot. This is stupid.
        new Fibonacci()->printFibonacciTimes(20);
    }
}

# Perl doesn't automatically call main method.
OutputFibonacci::main();
Konrad Borowski
fuente
4

J y ... nadie lo adivinará (editar: dc)

Esta es mi segunda entrada; Aquí hay una pieza de código J válido, que devuelve 1:

10 o. 1 r. 2 i. 4 [ ( 0:`1: @. (2&|)) ] 8 #: *:@+: 42

Estoy esperando uno o dos días antes de decir cuál es el otro idioma que ejecuta el mismo código sin ningún error. Solo deja comentarios para tratar de adivinar.

editar: El otro idioma es el lenguaje basado en la pila de la antigua calculadora Unix dc.

Thomas Baruchel
fuente
3
Se ejecuta sin errores en GolfScript, BF, HQ9 +, ...
Peter Taylor
OK, no sabía que tantos idiomas podrían hacerlo. Edito el código para poner el idioma que realmente elegí.
Thomas Baruchel
@ ברוכאל se ejecuta sin errores en esos idiomas porque esos idiomas no tienen errores o no tienen errores aplicables a este código. P.ej. Brainfuck ignora todos los personajes que no están en él, .,+-<>[]por lo que su programa es equivalente a ...[.]+en brainfuck, que es un programa válido pero inútil. AFAIK un programa brainfuck solo puede ser inválido si no coincide [].
immibis
@immibis. Esto es falso dc es una calculadora antigua y puedo asegurar que cambiar una cosa en mis códigos generaría un error. Pasé mucho tiempo en algunas partes del código para descubrir alguna forma complicada de poner las letras en el orden correcto. Mi código PostScript / dc es bastante extremo: no hay error, pero cambiar cualquier cosa lo hará defectuoso. dc no tiene nada que ver con "esos idiomas"; dc es aproximadamente 20 o 30 años mayor que "esos idiomas"; generalmente se instala en cualquier distribución de Linux. Por favor, navegue un poco si no lo ha escuchado.
Thomas Baruchel
1
@ ברוכאל entendiste mal - Estaba hablando de brainfuck, HQ9 +, golfscript, etc. - no dc.
immibis
4

dc ejecutando un archivo PostScript

DC puede ejecutar el siguiente fragmento de código sin error:

10 10 10 10 10 42 32 10 10
stop % first send a stop
0 0 srand rand
le pop pop 3.14 sin
lt 2 3 lt and pop
le 2 10 le xor
pop pop pop 1 0 0
<< /sox 2 >> [ exch begin sox end ] aload
3.14 floor
Thomas Baruchel
fuente
3

ML / (estricto) Haskell en Java

Esto es de un proyecto real real. Utiliza estructuras de datos inmutables persistentes y utiliza la recursividad incluso cuando no es necesario. En realidad, se parece más a Kore (el lenguaje que implementa el proyecto) en Java, pero el estilo es básicamente el mismo que ML. Pero la filosofía de Kore es que el autor no debe formatear su código, por lo que ninguno de los códigos Java está formateado (está autoformatado por eclipse).

soltar n elementos de una lista :

  public static <T> List<T> drop(List<T> l, Integer n) {
    return n == 0 ? l : drop(l.cons().tail, n - 1);
  }

En ML / Haskell, donde harías coincidir el patrón para extraer la cabeza y la cola, aquí dices list.cons().xy list.cons().tail.

inserte un elemento en una lista :

  public static <T> List<T> insert(List<T> l, Integer i, T x) {
    if (i == 0)
      return cons(x, l);
    return cons(l.cons().x, insert(l.cons().tail, i - 1, x));
  }

La lista se define literalmente cómo se definiría el tipo de datos algebraicos. Aquí hay una versión con el repetitivo generado por el eclipse eliminado:

public final class List<T> {

  public static final class Nil<T> {
  }

  public static final class Cons<T> {
    public final T x;
    public final List<T> tail;

    public Cons(T x, List<T> tail) {
      if (x == null)
        throw new RuntimeException("null head");
      if (tail == null)
        throw new RuntimeException("null tail");
      this.x = x;
      this.tail = tail;
    }
  }

  private final Nil<T> nil;
  private final Cons<T> cons;

  private List(Nil<T> nil, Cons<T> cons) {
    this.nil = nil;
    this.cons = cons;
  }

  public boolean isEmpty() {
    return nil != null;
  }

  public Nil<T> nil() {
    if (nil == null)
      throw new RuntimeException("not nil");
    return nil;
  }

  public Cons<T> cons() {
    if (cons == null)
      throw new RuntimeException("not cons");
    return cons;
  }

  public static <T> List<T> cons(Cons<T> cons) {
    if (cons == null)
      throw new RuntimeException("constructor received null");
    return new List<T>(null, cons);
  }

  public static <T> List<T> nil(Nil<T> nil) {
    if (nil == null)
      throw new RuntimeException("constructor received null");
    return new List<T>(nil, null);
  }
}

Aquí hay una estructura de datos de mapas implementada en términos de un trie :

public final class Map<K, V> {
  private final Tree<Character, Optional<Pair<K, V>>> tree;
  // keys are sorted in reverse order so entrySet can use cons instead of append
  private final Comparer<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> comparer =
      new PairLeftComparer<Character, Tree<Character, Optional<Pair<K, V>>>>(
          new ReverseComparer<Character>(new CharacterComparer()));

  private Map(Tree<Character, Optional<Pair<K, V>>> tree) {
    this.tree = tree;
  }

  public static <K, V> Map<K, V> empty() {
    return new Map<K, V>(new Tree<Character, Optional<Pair<K, V>>>(
        OptionalUtils.<Pair<K, V>> nothing(),
        ListUtils
            .<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> nil()));
  }

  public Optional<V> get(K k) {
    Tree<Character, Optional<Pair<K, V>>> t = tree;
    for (char c : k.toString().toCharArray()) {
      Tree<Character, Optional<Pair<K, V>>> t2 = getEdge(t, c);
      if (t2 == null)
        return nothing();
      t = t2;
    }
    if (t.v.isNothing())
      return nothing();
    return some(t.v.some().x.y);
  }

  public Map<K, V> put(K k, V v) {
    return new Map<K, V>(put(tree, k.toString(), v, k));
  }

  private Tree<Character, Optional<Pair<K, V>>> put(
      Tree<Character, Optional<Pair<K, V>>> t, String s, V v, K k) {
    if (s.equals(""))
      return new Tree<Character, Optional<Pair<K, V>>>(some(Pair.pair(k, v)),
          t.edges);
    char c = s.charAt(0);
    Tree<Character, Optional<Pair<K, V>>> t2 = getEdge(t, c);
    if (t2 == null)
      return new Tree<Character, Optional<Pair<K, V>>>(
          t.v,
          sort(
              cons(
                  pair(
                      c,
                      put(new Tree<Character, Optional<Pair<K, V>>>(
                          OptionalUtils.<Pair<K, V>> nothing(),
                          ListUtils
                              .<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> nil()),
                          s.substring(1), v, k)), t.edges), comparer));
    return new Tree<Character, Optional<Pair<K, V>>>(t.v, sort(
        replace(pair(c, put(t2, s.substring(1), v, k)), t.edges), comparer));
  }

  private List<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> replace(
      Pair<Character, Tree<Character, Optional<Pair<K, V>>>> edge,
      List<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> edges) {
    if (edges.cons().x.x.equals(edge.x))
      return cons(edge, edges.cons().tail);
    return cons(edges.cons().x, replace(edge, edges.cons().tail));
  }

  // I consider this O(1). There are a constant of 2^16 values of
  // char. Either way it's unusual to have a large amount of
  // edges since only ASCII chars are typically used.
  private Tree<Character, Optional<Pair<K, V>>> getEdge(
      Tree<Character, Optional<Pair<K, V>>> t, char c) {
    for (Pair<Character, Tree<Character, Optional<Pair<K, V>>>> p : iter(t.edges))
      if (p.x.equals(c))
        return p.y;
    return null;
  }

  public Map<K, V> delete(K k) {
    return new Map<K, V>(delete(tree, k.toString()).x);
  }

  private Pair<Tree<Character, Optional<Pair<K, V>>>, Boolean> delete(
      Tree<Character, Optional<Pair<K, V>>> t, String k) {
    if (k.equals(""))
      return pair(
          new Tree<Character, Optional<Pair<K, V>>>(
              OptionalUtils.<Pair<K, V>> nothing(), t.edges), t.edges.isEmpty());
    char c = k.charAt(0);
    Tree<Character, Optional<Pair<K, V>>> t2 = getEdge(t, c);
    if (t2 == null)
      return pair(t, false);
    Pair<Tree<Character, Optional<Pair<K, V>>>, Boolean> p =
        delete(t2, k.substring(1));
    List<Pair<Character, Tree<Character, Optional<Pair<K, V>>>>> edges = nil();
    for (Pair<Character, Tree<Character, Optional<Pair<K, V>>>> e : iter(t.edges))
      if (!e.x.equals(c))
        edges = cons(e, edges);
    if (!p.y)
      return pair(
          new Tree<Character, Optional<Pair<K, V>>>(t.v, cons(pair(c, p.x),
              edges)), false);
    boolean oneEdge = t.edges.cons().tail.isEmpty();
    return pair(new Tree<Character, Optional<Pair<K, V>>>(t.v, edges), oneEdge
        && t.v.isNothing());

  }

  public static class Entry<K, V> {
    public Entry(K k, V v) {
      this.k = k;
      this.v = v;
    }

    public final K k;
    public final V v;

  }

  public List<Entry<K, V>> entrySet() {
    return entrySet(ListUtils.<Entry<K, V>> nil(), tree);
  }

  private List<Entry<K, V>> entrySet(List<Entry<K, V>> l,
      Tree<Character, Optional<Pair<K, V>>> t) {
    if (!t.v.isNothing()) {
      Pair<K, V> p = t.v.some().x;
      l = cons(new Entry<K, V>(p.x, p.y), l);
    }
    for (Pair<Character, Tree<Character, Optional<Pair<K, V>>>> e : iter(t.edges))
      l = entrySet(l, e.y);
    return l;
  }
}

Los tipos comienzan a ocupar tanto espacio como el código. Por ejemplo, en put , el método tiene 302 caracteres de tipos y 343 caracteres de código (sin contar espacios / líneas nuevas).

Perro
fuente
2

BÁSICO en Ruby

Implementado esto hace mucho tiempo. La fuente está en GitHub . Inspirado en algo similar en Scala

Preparar

#!/usr/bin/env ruby

if caller.empty? && ARGV.length > 0
  $file = ARGV[0]
else
  $file = caller.last.split(':').first
end

require 'pp'

class String
  def %(other)
    self + other.to_s
  end
end

class RBaysick
  @@variables = {}
  @@code = []
  @@line = 0

  def initialize(contents)
    $DONT_RUN = true # To avoid endless loops.

    contents.gsub!(/( |\()'([^\W]+)/, '\1:\2 ')

    contents.gsub!(/(^| |\()(:[^\W]+)/, '\1GET(\2)')

    contents.gsub!(/ IF (.*) THEN (.*)/, ' IF { \1 }.THEN { GOTO \2 }')
    contents.gsub!(/LET *\(([^ ]+) *:= *(.*)\)/, 'LET(\1) { \2 }')
    contents.gsub!(/(LET|INPUT)(\(| )GET\(/, '\1\2(')
    contents.gsub!(/ \(/, '(')

    contents.gsub!(/^(\d+) (.*)$/, 'line(\1) { \2 }')

#    contents.gsub!(/(\)|\}|[A-Z]) ([A-Z]+)/, '\1.\2')

    contents.gsub!(/ END /, ' __END ')
    contents.gsub!(/^RUN/, '__RUN')

    puts contents if $DEBUG
    eval contents
  end

  def __RUN
    while @@line > -1
      puts "#{@@line}: #{@@code[@@line].inspect}" if $DEBUG
      unless @@code[@@line].nil?
        @@increment = true
        @@code[@@line].call
        next unless @@increment
      end
      @@line += 1
    end
  end

  class If < Struct.new(:value)
    def THEN
      yield if value
    end
  end

  def method_missing(name, *args)
    puts "Missing: #{name.to_s}(#{args.map(&:inspect).join(', ')})" if $DEBUG
  end

  def variables
    @@variables
  end

  def line(line, &block)
    @@code[line] = block
  end

  def add(line, cmd, *args)
    puts "DEBUG2: #{cmd.to_s}(#{args.map(&:inspect).join(', ')})" if $DEBUG
    @@code[line] = send(cmd, *args)
  end

  def IF
    ::RBaysick::If.new(yield)
  end

  def PRINT(str)
    puts "PRINT(#{str.inspect})" if $DEBUG
    puts str
    true
  end

  def LET(name, &block)
    puts "LET(#{name.inspect}, #{block.inspect})" if $DEBUG
    @@variables[name] = block.call
  end

  def GET(name)
    puts "GET(#{name.inspect}) #=> #{@@variables[name].inspect}" if $DEBUG
    @@variables[name]
  end

  def INPUT(name)
    puts "INPUT(#{name.inspect})" if $DEBUG
    LET(name) { $stdin.gets.chomp.to_i }
  end

  def ABS(val)
    puts "ABS(#{val.inspect}) #=> #{val.abs.inspect}" if $DEBUG
    val.abs
  end

  def GOTO(line)
    @@increment = false
    @@line = line
  end

  def __END
    exit
  end
end

RBaysick.new(open($file).read) unless $DONT_RUN || ($0 != __FILE__)

Código BÁSICO

#!./rbaysick.rb

10 PRINT "Welcome to Baysick Lunar Lander v0.0.1"
20 LET ('dist := 100)
30 LET ('v := 1)
40 LET ('fuel := 1000)
50 LET ('mass := 1000)

60 PRINT "You are a in control of a lunar lander."
70 PRINT "You are drifting towards the surface of the moon."
80 PRINT "Each turn you must decide how much fuel to burn."
90 PRINT "To accelerate enter a positive number, to decelerate a negative"

100 PRINT "Distance " % 'dist % "km, " % "Velocity " % 'v % "km/s, " % "Fuel " % 'fuel
110 INPUT 'burn
120 IF ABS('burn) <= 'fuel THEN 150
130 PRINT "You don't have that much fuel"
140 GOTO 100
150 LET ('v := 'v + 'burn * 10 / ('fuel + 'mass))
160 LET ('fuel := 'fuel - ABS('burn))
170 LET ('dist := 'dist - 'v)
180 IF 'dist > 0 THEN 100
190 PRINT "You have hit the surface"
200 IF 'v < 3 THEN 240
210 PRINT "Hit surface too fast (" % 'v % ")km/s"
220 PRINT "You Crashed!"
230 GOTO 250
240 PRINT "Well done"

250 END

RUN
Duckinator
fuente
2

Haskell en plantillas C ++

Hice este FizzBuzz en plantillas C ++ hace unos meses en una alondra. Es más o menos una implementación del siguiente código Haskell, todo en plantillas C ++. De hecho, incluso la aritmética de enteros se vuelve a implementar en el nivel de tipo. ¡Observe que ninguna de las plantillas usa parámetros int!

El código de Haskell:

import Control.Monad

m `divides` n = (n `mod` m == 0)

toFizzBuzz n
    | 15 `divides` n = "FizzBuzz"
    |  5 `divides` n = "Buzz"
    |  3 `divides` n = "Fizz"
    |      otherwise = show n

main = mapM_ putStrLn $ take 100 $ map toFizzBuzz [1..]

y la versión de metaprogramación de plantilla C ++:

//  
//  Lazy compile-time fizzbuzz computed by C++ templates,
//  without conditionals or the use of machine arithmetic.
//
//         -- Matt Noonan ([email protected])

#include <iostream>

using namespace std;

//
//  The natural numbers: Nat = Zero | Succ Nat
//

template <typename n>
struct Succ
{
  typedef Succ eval;
  static const unsigned int toInt = 1 + n::toInt;
  static void print(ostream & o) { o << toInt; }
};

struct Zero
{
  typedef Zero eval;
  static const unsigned int toInt = 0;
  static void print(ostream & o) { o << toInt; }
};

//
//  Arithmetic operators
//    Plus Zero n = n
//    Plus Succ(n) m = Plus n Succ(m)
//    Times Zero n = Zero
//    Times Succ(n) m = Plus m (Times n m)
//

template <typename a, typename b>
struct Plus
{
  typedef typename Plus<typename a::eval,
                        typename b::eval>::eval eval;
};

template <typename M>
struct Plus <Zero, M>
{ typedef typename M::eval eval; };

template <typename N, typename M>
struct Plus <Succ<N>, M>
{ typedef typename Plus<N, Succ<M> >::eval eval; };

template <typename a, typename b>
struct Times
{
  typedef typename Times<typename a::eval,
                         typename b::eval>::eval eval;
};

template <typename M>
struct Times <Zero, M>
{ typedef Zero::eval eval; };

template <typename N, typename M>
struct Times <Succ<N>, M>
{ typedef typename Plus<M,
                        typename Times<N,M>::eval
                        >::eval eval; };

//
//  Lists
//

struct Nil
{
  typedef Nil eval;
  static void print(ostream & o) { }
};

template <typename x, typename xs>
struct Cons
{
  typedef Cons eval;
  static void print(ostream & o) {
    x::eval::print(o); o << endl; xs::eval::print(o);
  }
};

//
//  Take the first n elements of a list
//

template <typename, typename> struct Take;

template <typename _> struct Take<Zero,_>
{ typedef Nil eval; };

template <typename n, typename x, typename xs>
struct Take<Succ<n>, Cons<x,xs> >
{
  typedef Cons<x, Take<n, xs> > eval;
};

template <typename a, typename b>
struct Take
{
  typedef typename Take<typename a::eval,
                        typename b::eval>::eval eval;
};

//
//  Iterate f x0 makes the infinite list
//  x0, f(x0), f(f(x0)), ...
//

template <template<typename> class f, typename x0> struct Iterate
{
  typedef Cons<x0, Iterate<f, f<x0> > > eval;
};

//
//  Map a function over a list
//

template <template<typename> class a, typename b> struct Map
{ typedef typename Map<a,
                       typename b::eval>::eval eval;
};

template <template<typename> class f>
struct Map<f, Nil>
{ typedef Nil eval; };

template <template<typename> class f, typename x, typename xs>
struct Map<f, Cons<x,xs> >
{
  typedef Cons<f<x>, Map<f,xs> > eval;
};

//
//  Some useful things for making fizzes and buzzes
//

struct Fizz
{ static void print(ostream & o) { o << "Fizz"; } };

struct Buzz
{ static void print(ostream & o) { o << "Buzz"; } };

struct FizzBuzz
{ static void print(ostream & o) { o << "FizzBuzz"; } };

//
//  Some useful numbers
//

typedef Succ<Zero> One;
typedef Succ<One> Two;
typedef Succ<Two> Three;
typedef Plus<Two, Three> Five;
typedef Times<Two, Five> Ten;
typedef Times<Three, Five> Fifteen;
typedef Times<Ten, Ten> OneHundred;

//
//  Booleans
//

struct True {};
struct False {};

//
//  If/then/else
//

template <typename p, typename t, typename f>
struct If
{
  typedef typename If<typename p::eval, t, f>::eval eval;
  static void print(ostream & o) { eval::print(o); }
};

template <typename t, typename _>
struct If<True, t, _>
{
  typedef t eval;
};

template <typename _, typename f>
struct If<False, _, f>
{ typedef f eval; };

//
//  Testing if x divides y
//

template <typename a, typename b, typename c>
struct _Divides
{
  typedef typename _Divides<typename a::eval,
                            typename b::eval,
                            typename c::eval>::eval eval;
};

template <typename _, typename __>
struct _Divides<_, __, Zero> { typedef False eval; };

template <typename a>
struct _Divides<a, Zero, Zero> { typedef True eval; };

template <typename a, typename b>
struct _Divides<a, Zero, b>
{
  typedef typename _Divides<a, a, b>::eval eval;
};

template <typename _, typename n, typename m>
struct _Divides<_, Succ<n>, Succ<m> >
{
  typedef typename _Divides<_, n, m>::eval eval;
};

template <typename a, typename b>
struct Divides
{
  typedef typename _Divides<a, a, b>::eval eval;
};

//
//  "Otherwise" sugar
//

template <typename a>
struct Otherwise
{
  typedef typename a::eval eval;
  static void print(ostream & o) { a::eval::print(o); }
};

//
//  Convert a number to fizzes, buzzes as appropriate
//

template <typename n>
struct toFizzBuzz
{
  typedef typename
    If< Divides<Fifteen, n>, FizzBuzz,
    If< Divides<   Five, n>,     Buzz,
    If< Divides<  Three, n>,     Fizz,
    Otherwise<                   n
    > > > >::eval eval;
};

int main(void)
{
  // Make all of the natural numbers
  typedef Iterate<Succ, One> Naturals;

  // Apply fizzbuzz rules to every natural number
  typedef Map<toFizzBuzz, Naturals> FizzBuzzedNaturals;

  // Print out the first hundred fizzbuzzed numbers
  Take<OneHundred, FizzBuzzedNaturals>::eval::print(cout);

  return 0;
}
Matt Noonan
fuente