Escreva um programa no seu idioma favorito em outro idioma [fechado]

168

O Real Programmer determinado pode escrever programas Fortran em qualquer idioma.

de programadores reais não usam Pascal

Sua tarefa é escrever o programa na sua linguagem de programação preferida, mas você pode usar apenas outra linguagem. Ou seja, jogue fora todas as convenções de codificação de um idioma e substitua-as por convenções de codificação de outro idioma. Quanto mais melhor. Faça com que seu programa pareça ter sido escrito em outro idioma.

Por exemplo, um fã de Python que odeia Java pode escrever o seguinte programa Python em Java:

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

O entusiasta de Pascal forçado a usar C poderia escrever o seguinte:

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

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

Você tem que escrever um programa completo. O programa não precisa fazer nada de útil.

Boa sorte. Este é um concurso de popularidade, portanto o código com mais votos vence!

popularity-contest el.pescado
fonte
1
@ m.buettner criar o seu arquivo com a extensão .litcoffee. Isso pode ajudar.
Ismael Miguel
Uma longa (e previamente escrito, e não auto-suficiente) pouco por uma resposta, mas: scanner de Postscript em Postscript em C .
Luser droog 21/03/2014
51
Eu não acho que você (ou a maioria das respostas) entenda o objetivo da citação. Não é que um programador real escreva um código que se assemelhe a Fortran, mesmo que esteja escrevendo em Pascal ou LISP: é que ele aplica uma maneira de pensar em Fortran, mesmo quando escreve em Pascal ou LISP; por exemplo " Como todos os programadores reais sabem, a única estrutura de dados útil é a matriz. ". Ótimas respostas seriam código procedural em Prolog, código funcional em C, código orientado a objetos em Pascal.
Peter Taylor
1
Espero que alguém vai fazer um dialeto Lisp em, bem, qualquer coisa, mas um outro dialeto Lisp ...
itsjeyd
6
Décima regra de programação de @itsjeyd Greenspun : "Qualquer programa C ou Fortran suficientemente complicado contém uma implementação lenta ad-hoc, especificada informalmente, cheia de erros e lenta de metade do CommonLisp."
Joshua Taylor

Respostas:

142

C em C ++

#include <stdio.h>

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

fonte
60
Eu vejo o que você fez lá;)
el.pescado
27
Bem, isso é um truque barato, vendo como C ++ é 'para trás compatível' com C.
Agi Hammerthief
5
@AlexM. Eu acho que seria mais no espírito da pergunta se este fosse um exemplo mais longo (processual) que claramente se beneficiaria do uso de algumas classes e que usa outros idiomas C, nos quais alguma bondade do STL seria muito mais razoável (digamos, em char*vez de std::string).
Martin Ender
47
Válido em C, C ++, Objective-C e Objective-C ++! Que resposta maravilhosamente poliglota.
Nneonneo 23/03
7
@ BenJackson Psh, programadores de C reais usam char *argv[]!
Thomas
122

montagem x86 no GNU C

Não, não usei apenas a asmpalavra - chave, já que a pergunta estabelecida é para programadores reais ... isso deve funcionar bem no ARM.

(Apenas para provar o ponto, eu não "escrevi" o assembly - é a saída produzida por GCC Clang (503.0.38) para o código comentado no topo, traduzido cegamente em macros.

Isso funciona apenas no modo de 32 bits. Tudo bem, já que os programadores reais codificam para o tamanho da palavra de qualquer maneira.

#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
    ))
}

Basta olhar para todos os elencos. Elenco significa que eu sou um programador mais real que o compilador, certo?

Leushenko
fonte
8
+1, isso é ... distorcido. ;) Eu realmente gosto de como você lidou call, em particular.
Ilmari Karonen 22/03
2
Uau. É um ótimo trabalho.
Jack Aidley
Eu tinha um montador para o C64 que funcionava assim. Ele adicionou palavras-chave BASIC para todas as instruções do 6510 e lembro que você as envolveu for pass=1:3...next. Executá-lo no intérprete BASIC o montou.
Ben Jackson
5
Isso é pura poesia.
Nicu Stiurca 27/03
1
Este é um homem duro, o compilador com certeza está surpreso.
internets é feito de catz
102

Inglês em 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

Alguma idéia para eliminar o ;?

urzeit
fonte
18
Sério, pessoal.
Kyle Strand
2
por que definir theduas vezes?
27414 Joshua Taylor
16
melhor prevenir do que remediar ;-)
urzeit
20
Agora faça um haiku.
Nicu Stiurca 27/03
1
Pode você#define . ;
mbomb007 21/03
74

Brainfuck em JavaScript

Javascript é uma linguagem difícil! Vamos usar o Brainfuck, uma linguagem mais compreensível: 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)')
)

Eu acho que escrevi um intérprete cerebral em javascript.

O exemplo acima simplesmente gera Hello World!e ignora a entrada (sem ,símbolo).
Mas isso também funciona com entradas! Por exemplo, tente ,+>,+>,+>,+<<<.>.>.>.e digite golfa caixa de diálogo. Ele exibirá os próximos caracteres na tabela ASCII:hpmg

EDIT : Breve explicação para pessoas que não conhecem o cérebro.
Imagine uma matriz infinita de números inteiros ainicializados como zero em qualquer lugar, um ponteiro em um elemento dessa matriz ie uma entrada do usuário u.
Brainfuck é realmente fácil de aprender, mas difícil de escrever:

  • + incrementos para o valor atual: a[i]++
  • - diminui: a[i]--
  • > faz com que o ponteiro aponte o próximo elemento: i++
  • < o anterior : i--
  • [e ]defina um loop que quebra quando o valor atual é zero:while (a[i]) { ... }
  • . imprima o elemento atual: String.fromCharCode(a[i])
  • , define o elemento atual com a entrada do usuário: u.charCodeAt(...)
Michael M.
fonte
22
+1 no humor ao afirmar que o cérebro é mais compreensível que o JavaScript.
Agi Hammerthief
Tem certeza de que os caracteres Brainfuck nas replaceinstruções não afetam o programa?
Fraxtil
3
@fra Este arquivo não é um programa brainfuck, é um programa javascript que contém um programa brainfuck que é convertido em javascript em tempo de execução.
Undergroundmonorail
3
Bem, --imais rápido que i--? Parece falso desde anos: jsperf.com/decrementgolf .
Michael M.
4
Isso não apenas é uma apresentação muito criativa para o concurso, mas também explica a sintaxe do cérebro com muita clareza. +10 se eu pudesse!
Sebastianh
74

Acho que o brilhante Lennart Augustsson já venceu isso duas vezes.

Primeiro, aqui está um exemplo de sua implementação de "hack de fim de semana" do BASIC como DSL Haskell Monadic, 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 sobrecarregando o tipo de número. Os números das linhas são realmente funções que aceitam argumentos. O restante da linha são argumentos para a função. A função retorna uma representação da Abstract Syntax Tree para o intérprete do BASIC trabalhar.

Também recomendo que você verifique a entrada de Augustsson no Concurso Internacional de Ofuscação C de 2006, no qual ele conseguiu entrar em 4k:

  • Um intérprete de bytecode, escrito em um subconjunto de C (que ele chama de Ofuscado C).
  • Um compilador C -> bytecode ofuscado , escrito em bytecode.

Eles podem compartilhar o mesmo arquivo porque o código de byet é colocado nos comentários em C.

Faz alguns anos que acompanhei o trabalho de Augustsson, então pode haver outras coisas brilhantes que ele inventou desde então ...

Pitarou
fonte
2
É Augustsson, não Augustssen.
Hans Lundmark 23/03
@HansLundmark Thanks. Corrigido.
Pitarou
71

PHP e Javascript

Este é um poliglota:

Você pode executar esse código nos dois 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]));

O truque aqui é que o Javascript usa seqüências de escape em strings começando com 'e ".
Por outro lado, o PHP usa apenas seqüências de escape em strings começando com "e <<<.

Em seguida, declaramos a função printf, que é semelhante a, printmas gera uma string formatada no PHP.

O PHP exige que os vars iniciem $, enquanto o Javascript simplesmente permite.

Ismael Miguel
fonte
Ninguém está usando Array(…)em JS, e está claramente array(…)em PHP. […]seria muito melhor;)!
Blackhole 23/03
12
Não me importo se as pessoas usam Array()em JS ou não: me importo de ter um poliglota VERDADEIRO . Estou cometendo um dos piores crimes de JS com esse código, mas tudo o que quero é que ele execute e faça exatamente a mesma coisa em ambos, mas parecendo JS e PHP ao mesmo tempo.
Ismael Miguel
E btw, [...]é inválido no PHP <5.4.0, o que é ruim ....... Se eu jogar isso no PHP 4, 5 ou Javascript, espero que funcione, em vez de fornecer erros de sintaxe em todos os lugares.
Ismael Miguel
2
Se você deseja que seu código se pareça com JS, você deve usá-lo […], o que parece bastante padrão em PHP e, portanto, é bom para seu objetivo. E, a propósito, PHP <5.4? Hora de atualizar, cara ...
Blackhole 23/03
8
A compatibilidade é mais importante do que "aparência". E Arrayé o nome DIREITO do construtor do objeto Array. Basicamente, usar []é o mesmo que Array(). Não vejo nada de ruim nisso. Mas eu tenho uma pergunta simples: funciona? (btw, eu tenho de usar php 5.3.28 no trabalho.)
Ismael Miguel
55

Brainfuck em JS

[][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[
!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[
+!+[]]]]][([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(
![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!
![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+
[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]
]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[
]+!+[]+!+[]+!+[]]]]+([][[]]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+[]+!+[]]]]+(!!
[]+[])[+[[+[]]]]+(!![]+[])[+[[+!+[]]]]+([][[]]+[])[+[[+[]]]]+([][(![]+[])[+[[
+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!
![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+
[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[
[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!!
[]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]+!+[]
+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]((![]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+
[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]+(!![]+[])[+[[+[]]]
]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[
+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[
+[[+!+[]]]]]+[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+[+!+[]]+([][(![]+[]
)[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]
]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+
[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]]])()
Clyde Lobo
fonte
12
Não vejo nenhum cérebro aqui. Nem mesmo um único caractere em><,.-
Michael M.
8
@ Michael: Quem disse que não é um programa que faz um loop infinito?
precisa
19
é esse JSF * ck?
8
Como na Terra que ele faz isso ?
Nandhp 26/03
4
Oo. Alguém finalmente fez isso. Passei algum tempo tentando descobrir como escrever um programa JS usando apenas os caracteres +! [] (), Mas nunca consegui descobrir. Eu preciso analisar isso quando eu tiver tempo ...
Matti Virkkunen
54

Este é um dos vencedores da IOCCC de 2005 , um programa C que, exceto por esse conjunto de definições, parece um 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
fonte
3
Verbosidade no seu melhor.
QWR
39

C ++ em C

OK, então você é um programador C ++, mas é forçado a usar C? Não tem problema, você só precisa escrever alguns cabeçalhos adicionais ausentes no C. Por exemplo, aqui está um programa válido do Hello World em C:

No arquivo de cabeçalho suplementar iostream, escreva:

#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

No arquivo string, escreva

#define string

No arquivo helloworld.c(seu código C real), escreva

#include <iostream>
#include <string>

using namespace std;

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

E ao compilar helloworld.ccom um compilador C, instrua o compilador a também procurar por <...>arquivos de cabeçalho onde quer que você os armazene iostreame string, por exemplo, se estiver compilando com o gcc e colocando os arquivos iostreame stringno diretório atual, compile com

gcc helloworld.c -o helloworld -I.

Nota: O volatilecabeçalho in iostreamestá lá para permitir uma compilação sem aviso, mesmo no nível máximo de aviso (uma leitura de uma variável volátil é considerada como tendo efeito).

celtschk
fonte
3
Isso é um pouco de trollagem de código, não é?
Mr Lister
Bem, o programa faz exatamente o que parece fazer, não é?
Celtschk
8
Muito mais engraçado e impressionante dessa maneira do que C em C ++.
Kyle Strand
Que tipo de compilador avisa se você não usa volatileaqui e que tipo de aviso?
R. Martinho Fernandes
1
@ KyleStrand Mas o "C em C ++" está mais em sintonia com a citação na pergunta. Programadores reais programam em C, mesmo que tenham um compilador C ++.
Lister
36

CQL - linguagem de consulta com cafeína

(ou "SQL na cafeína")

Isso pode ter sido um pouco ambicioso demais. Aqui está uma tentativa de escrever código declarativo SQL (ish) no CoffeeScript . Isso requer o recurso Proxy do ECMAScript 6 . Você pode testá-lo no nó com --harmony-proxies.

Vamos configurar um modelo para definir proxies. (Retirado do comentário de Benvie sobre esta questão )

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
)();

Agora defina um objeto proxy e algumas variáveis ​​e funções globais suspeitas:

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

Bem, isso foi bastante configurado! Mas agora podemos fazer o seguinte (entrada / saída no estilo de console):

> 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 ] ]

Não é um poliglota de verdade, mas esse não é realmente o ponto. Eu sei que isso @é usado para variáveis ​​no SQL, mas preciso de todos os @s para nomes de colunas e tabelas, porque não encontrei uma maneira de proxy do objeto global (e não ficaria surpreso se realmente não for possível - e por uma boa razão).

Também mudei alguns parênteses para colchetes (em particular depois VALUESe IN). Infelizmente, o que eu não consegui descobrir é uma maneira de permitir condicionais normais como year > 2000, porque eles seriam avaliados para um booleano imediatamente.

Ainda assim, isso se parece muito com o SQL e é definitivamente mais declarativo do que imperativo / funcional / orientado a objetos; portanto, deve se qualificar bem para a pergunta. Na verdade, estou pensando que, se eu aperfeiçoasse um pouco o código e suportasse mais alguns recursos, esse poderia ser um módulo útil do CoffeeScript.

Enfim, isso foi divertido! :)

Para quem não conhece muito o CoffeeScript, as consultas SQL são compiladas com o seguinte 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
fonte
Isso é bastante configurado, mas parece bom. Não sou programador do CoffeeScript, mas parece ótimo. O @no SQL é usado para variáveis ​​de sessão.
Ismael Miguel
Decidi tornar as palavras-chave globais agora. Agora, existem apenas @s para nomes de colunas e tabelas.
Martin Ender
Agora parece muito com SQL! Você fez um bom trabalho com este!
Ismael Miguel
1
Eu não ligo muito para o café, mas isso é incrível.
KRyan
2
@ tac obrigado, mas não, eu apenas o cortei juntos para este desafio. Engraçado coincidência: refazer isso de uma maneira limpa e colocá-lo no GitHub estava na minha lista de projetos de codificação em potencial / de longo prazo até removê-lo esta manhã.
Martin Ender
27

Visual Basic 6 (em 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()

Também funciona em VBScript.

Escova de dente
fonte
1
Esperto. Você nem precisa da maioria dos pontos e vírgulas.
precisa saber é o seguinte
@ js1568 Obrigado! Agora removi os pontos e vírgulas que não são necessários.
Escova de dentes
20

F # em C ++

Abuso bastante sem imaginação e desagradável do pré-processador. Eu pensei que seria divertido alterar o C ++ para parecer uma linguagem completamente diferente, em vez de usar alguns apelidos para parecer Java ou PHP. Eu realmente não estou esperando que isso receba uma tonelada de votos, é uma entrada apenas por diversão.

#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

Experimente aqui .

Infelizmente, escrever algo para o STDOUT é tudo o que pode fazer, embora eu tenha certeza que se alguém jogou feitiçaria suficiente nele, poderia fazê-lo fazer mais.

Tony Ellis
fonte
2
Para que a última linha funcione em F #, teria que ser exit 0ou apenas 0.
Jwosty
20

Python e ... ninguém vai adivinhar (editar: dc)

Aqui está um código python válido, mas na verdade o programa é escrito em uma linguagem muito 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

O código é executado nos dois idiomas sem erros.

A combinação é muito louca; Eu ficaria feliz em esperar um dia ou dois antes de dizer qual é o outro idioma; por favor, deixe comentários para adivinhar.

editar: o idioma era o idioma baseado em pilha do dc. Você pode ver aqui palavras-chave bem conhecidas como for, if, or, in, mas apenas as letras importa! O ,que não tem significado em dc é transformado em um registro, porque a primeira vez que aparece é após a letra s(o mesmo para :).

Thomas Baruchel
fonte
1
A menos que o código faça a mesma coisa nos dois idiomas, suponho que um idioma como o Befunge possa fazer o truque.
Thomas Eding
OK, edito o código para colocar o idioma que realmente escolhi.
Thomas Baruchel 22/03
18

O C ++ permite escrever código do tipo lisp, com a 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
fonte
4
Bem vinda! Pedimos aos usuários que sinalizem suas postagens como Wiki da Comunidade quando a resposta não for seu próprio trabalho. (E dar a devida atribuição, mas você já fez isso, então obrigado!)
Jonathan Van Matre
Original ou não, você conseguiu meu voto :) #
itsjeyd
15

C # em espaço em branco

Ok, tente primeiro um desses, então vamos ver como vai. 

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!

E, caso a formatação tenha sido complicada por ter que colocar quatro espaços na frente de cada linha, aqui está novamente. para espaço e # para tab:

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
fonte
12

HTML e CSS

Não linguagens de programação, mas… este documento é HTML e CSS válidos :

<!-- 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>
<!-- */ -->

Isso funciona, porque comentários em HTML são permitidos em folhas de estilo por motivos históricos. Ah, e todo documento HTML válido também é um programa PHP válido, então também é PHP . :)

fuxia
fonte
2
Isso é bem engraçado e tudo, mas esse não é realmente um desafio poliglota .
Martin Ender
Como o CSS pode ser considerado completo , essa pode ser uma resposta válida.
Adam Davis
2
HTML e CSS não são linguagens de programação :)
Jet
9

C em Scala

A camada de ponte imita uma era mais romântica quando as strings ainda eram nulos e terminavam matrizes de bytes. 

// 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
fonte
"This program does not take parameters!"enganado ya
Erik the Outgolfer 06/09/16
8

sed e APL

Meu chefe quer que eu escreva scripts sed, mas eu prefiro escrever APL o dia todo. No entanto, ele está muito feliz com o meu trabalho, porque esses scripts funcionam perfeitamente com sua versão do sed:

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

Você pode experimentá-lo no meu novo site com este link permanente . É uma versão compilada em javascript do GNU APL. O lançamento final será mais tarde com o lançamento oficial do GNU APL, v. 1.3, mas você pode usá-lo perfeitamente para seus permalinks, se você gosta do GNU APL.

Thomas Baruchel
fonte
7

C em 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)));
    };
}

Obviamente, como cmainnão faz nada com argcou argv, o código de empacotamento de argumentos não tem efeito e, como cmainsempre retorna 0, o ramo "else" da instrução "if" está morto. Mas a declaração "if" não faz nada de qualquer maneira.

Todos os colchetes e ponto e vírgula são desnecessários, assim como a maioria dos parênteses e algumas das dopalavras - chave. A declaração "se" poderia ter sido escrita como if exitCode == 0 then exitWith ExitSuccess else exitWith (ExitFailure (fromIntegral exitCode)).

Tanner Swett
fonte
7

C ++ em diante

: #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";
}

Não é a solução mais flexível, mas funciona se escrita exatamente como mostrado.

Michael
fonte
7

Haskell em Java

("vanilla" Java 7, não Java 8) (Sim, eu sei que o boxe arruina o desempenho; e até mesmo tentar usar funções de ordem superior fica louco detalhadamente: D)

O Java possui uma sintaxe muito rígida; portanto, em vez de alterar a sintaxe, tentei tornar o código semanticamente mais semelhante ao estilo Haskell.

Editar - adicionado aplicativo de função parcial.

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());
    }
}

(Sim, tudo o que essa loucura faz é computar 6!)

Sarge Borsch
fonte
6

COBOL in AWK

No espírito da citação. AWK puro e não adulterado, como pode ser escrito por um programador COBOL.

A tarefa é contar os registros em um arquivo. Esta versão de desenvolvimento inicial está contando para teste. O arquivo correto será codificado posteriormente quando liberado do Teste de Unidade ...

Se eu conseguisse destacar a sintaxe para fazer verde fosforescente em preto, seria ótimo ...

Até acertamos os números das colunas nesta, são sete espaços em branco no início de cada linha (nunca feitos isso no awk antes) e quebrando as longas declarações de impressão na coluna 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
fonte
6

Brainfuck (ou qualquer outra coisa) na raquete

O módulo flexível e o sistema de macro da Racket permitem implementar o suporte ao módulo para linguagens inteiramente novas, tanto para domínios específicos quanto para fins gerais. Como há suporte imediato para o Datalog e o Algol 60 , os dois programas a seguir são válidos:

#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

Você também pode adicionar suporte para outros idiomas: por exemplo, veja a descrição de Danny Yoo sobre como implementar o suporte ao Brainfuck, que permite programas Racket, como:

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

E como o suporte é adicionado no nível do módulo compilado, é possível vincular módulos escritos em diferentes idiomas ou incorporar um trecho de um idioma dentro de um módulo escrito em outro.

Uri Zarfaty
fonte
5

SML em Java

Eu ainda tenho algum código antigo quando comecei a aprender Java e tentei usá-lo em um estilo funcional. Ligeiramente limpo:

/**
 * 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
fonte
5

Java em Perl

Pode contar como quebra de regra, mas eu não me importo. Obviamente, ele se parece com o programa Java. Imprime 20 números de Fibonacci, caso não seja óbvio.

Requer o módulo Inline :: Java para ser instalado.

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
fonte
4

J e ... ninguém vai adivinhar (editar: dc)

Esta é a minha segunda entrada; aqui está um trecho de código J válido, que retorna 1:

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

Estou aguardando um ou dois dias antes de dizer qual é o outro idioma executando o mesmo trecho de código sem erro. Apenas deixe comentários para tentar adivinhar.

edit: O outro idioma é o idioma baseado em pilha da antiga calculadora Unix dc.

Thomas Baruchel
fonte
3
Ele é executado sem erros em GolfScript, BF, HQ9 +, ...
Peter Taylor
OK, eu não sabia que tantas línguas poderiam fazer isso. Eu edito o código para colocar o idioma que realmente escolhi.
Thomas Baruchel 22/03
@ Ele roda sem erros nesses idiomas porque esses idiomas não possuem erros ou não são aplicáveis ​​a este código. Por exemplo. Brainfuck ignora todos os caracteres que não estão presentes, .,+-<>[]portanto seu programa é equivalente ao ...[.]+brainfuck, que é um programa válido, mas sem sentido. AFAIK, um programa de foda cerebral só pode ser inválido por incompatibilidade [].
immibis 27/03
@immibis. Isto é falso. dc é uma calculadora antiga e posso garantir que alterar uma coisa nos meus códigos geraria um erro. Passei muito tempo em algumas partes do código para descobrir uma maneira complicada de colocar as letras na ordem certa. Meu trecho de código Postscript / dc é bastante extremo: nenhum erro, mas mudar alguma coisa fará com que ela esteja com defeito. dc não tem nada a ver com "essas línguas"; dc é cerca de 20 ou 30 anos mais velho que "essas línguas"; geralmente é instalado em qualquer distribuição Linux. Por favor, navegue um pouco, se você não ouviu falar sobre isso.
Thomas Baruchel 27/03
1
@ ברוכאל você entendeu mal - eu estava falando sobre cérebro, HQ9 +, golfscript, etc. - não dc.
immibis 27/03
4

dc executando um arquivo PostScript

O dc pode executar o seguinte trecho de código sem erro:

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
fonte
3

ML / (Strict) Haskell em Java

Isto é de um projeto real real. Utiliza estruturas de dados imutáveis ​​persistentes e utiliza recursão mesmo quando não é necessário. Na verdade, é mais parecido com o Kore (a linguagem que o projeto implementa) em Java, mas o estilo é basicamente o mesmo que o ML. Mas a filosofia de Kore é que o autor não deve formatar seu código, portanto, nenhum código Java também é formatado (é auto-formatado pelo eclipse).

solte n elementos de uma lista :

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

Em ML / Haskell, onde você combinaria padrões para extrair a cabeça e a cauda, ​​aqui você diz list.cons().xe list.cons().tail.

insira um elemento em uma 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));
  }

Lista é definida literalmente como o tipo de dados algébrico seria definido. Aqui está uma versão com o clichê gerado pelo eclipse removido:

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);
  }
}

Aqui está uma estrutura de dados do mapa implementada em termos de um 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;
  }
}

Os tipos começam a ocupar tanto espaço quanto o código. Por exemplo, no método put , o método possui 302 caracteres de tipos e 343 caracteres de código (sem contar espaço / novas linhas).

Cão
fonte
2

BASIC em Ruby

Implementado há muito tempo. A fonte está no GitHub . Inspirado por uma coisa semelhante em Scala

Configuração

#!/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 BASIC

#!./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
patinador
fonte
2

Haskell em modelos C ++

Eu fiz este FizzBuzz em modelos C ++ há alguns meses atrás em uma cotovia. É praticamente uma implementação do seguinte código Haskell, tudo em modelos C ++. De fato, mesmo a aritmética inteira é reimplementada no nível do tipo --- observe que nenhum dos modelos usa parâmetros int!

O código 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..]

e a versão de metaprogramação do modelo 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
fonte