Напишите программу на вашем любимом языке на другом языке [закрыто]

168

Настоящий Программист может писать программы на Фортране на любом языке.

от настоящих программистов не пользуйтесь Pascal

Ваша задача - написать программу на выбранном вами языке программирования, но вы можете использовать только другой язык. То есть, отбросьте все соглашения о кодировании из одного языка и замените их соглашениями о кодировании из другого языка. Чем больше, тем лучше. Сделайте так, чтобы ваша программа выглядела так, как будто она написана на другом языке.

Например, поклонник Python, который ненавидит Java, может написать следующую программу Python на Java:

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

Энтузиаст Паскаля, вынужденный использовать C, мог написать это:

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

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

Вы должны написать полную программу. Программа не должна делать ничего полезного.

Удачи. Это конкурс популярности, поэтому выигрывает код с наибольшим количеством голосов!

popularity-contest el.pescado
источник
1
@ m.buettner создайте свой файл с расширением .litcoffee. Это может помочь.
Исмаэль Мигель
Немного долго (и ранее написанный, а не самодостаточный) для ответа, но: сканер Postscript в Postscript в C .
luser droog
51
Я не думаю, что вы (или большинство ответов) понимаете смысл цитаты. Дело не в том, что настоящий программист пишет код, который выглядит лексически как на Fortran, даже если он пишет на Pascal или LISP: дело в том, что он применяет образ мышления на Fortran, даже когда пишет на Pascal или LISP; например, « Как знают все настоящие программисты, единственной полезной структурой данных является массив ». Отличными ответами были бы процедурный код на Прологе, функциональный код на С, объектно-ориентированный код на Паскале.
Питер Тейлор
1
Я надеюсь, что кто-то сделает диалект Lisp на, ну, во всяком случае, кроме другого диалекта Lisp ...
itsjeyd
6
@itsjeyd Десятое правило программирования Гринспуна : «Любая достаточно сложная программа на C или Fortran содержит специальную, неофициально заданную, с ошибками, медленную реализацию половины CommonLisp».
Джошуа Тейлор

Ответы:

142

C в C ++

#include <stdio.h>

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

источник
60
Я вижу, что вы там сделали;)
el.pescado
27
Что ж, это дешевый трюк, поскольку C ++ «обратно совместим» с C.
Agi Hammerthief
5
@AlexM. Я думаю, что было бы больше в духе вопроса, если бы это был более длинный (процедурный) пример, который явно выиграл бы от использования некоторых классов и который использовал бы другие идиомы C, где некоторая ценность STL была бы намного более разумной (скажем, char*вместо std::string).
Мартин Эндер
47
Действительно в C, C ++, Objective-C и Objective-C ++! Какой чудесно многоглотный ответ.
nneonneo
7
@BenJackson Psh, настоящие программисты на C char *argv[]!
Томас
122

сборка x86 в GNU C

Нет, я не просто использовал это asmключевое слово, так как вопрос был задан для настоящих программистов ... это должно хорошо работать на ARM.

(Просто чтобы доказать это, я вообще не «писал» сборку - это вывод, созданный GCC Clang (503.0.38) для прокомментированного кода сверху, слепо переведенного в макросы.)

Это работает только в 32-битном режиме. Это нормально, так как настоящие программисты все равно кодируют до размера слова.

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

Просто посмотрите на все эти броски. Слепки среднее Я реальнее программист , чем компилятор, не так ли?

Leushenko
источник
8
+1, это ... искажено. ;) Мне очень нравится, как ты справился call, в частности.
Ильмари Каронен,
2
Ух ты. Это отличная работа.
Джек Эйдли
У меня был ассемблер для C64, который работал примерно так. Он добавил ключевые слова BASIC для всех инструкций 6510, и я помню, что вы обернулись for pass=1:3...nextвокруг него. Выполнение этого в бейсике интерпретатор собрал его.
Бен Джексон
5
Это чистая поэзия.
Нику Стирка
1
Это крутой человек, уверен компилятор.
интернет сделан из catz
102

Английский в 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

Есть идеи по устранению ;?

urzeit
источник
18
Серьезно, ребята.
Кайл Стрэнд
2
зачем определять theдважды?
Джошуа Тейлор
16
лучше безопасно, чем
потом
20
Теперь сделайте это хайку.
Нику Стирка,
1
Можете ли вы#define . ;
mbomb007
74

Brainfuck в JavaScript

Javascript - это сложный язык! Давайте использовать Brainfuck, более понятный язык: о)

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)')
)

Я думаю, что я написал интерпретатор Brainfuck в JavaScript.

Приведенный выше пример просто выводит Hello World!и игнорирует ввод (без ,символа).
Но это работает и с входами! Например, попробуйте ,+>,+>,+>,+<<<.>.>.>.ввести golfтекст в диалоговом окне. Он выведет следующие символы в таблицу ASCII:hpmg

РЕДАКТИРОВАТЬ : Краткое объяснение для людей, которые не знают о бреде.
Представьте себе бесконечный массив целых чисел, aинициализированных нулями везде, указатель на один элемент этого массива iи пользовательский ввод u.
Brainfuck действительно легко выучить, но трудно написать:

  • + приращения к текущему значению: a[i]++
  • - уменьшает это: a[i]--
  • > делает для точек указателя следующий элемент: i++
  • < предыдущий : i--
  • [и ]определить цикл, который прерывается, когда текущее значение равно нулю:while (a[i]) { ... }
  • . напечатать текущий элемент: String.fromCharCode(a[i])
  • , устанавливает текущий элемент с пользовательским вводом: u.charCodeAt(...)
Майкл М.
источник
22
+1 за юмор, заявив, что мозговой трафик более понятен, чем JavaScript.
Agi Hammerthief
Вы уверены, что символы Brainfuck внутри replaceоператоров не влияют на программу?
Fraxtil
3
@fra Этот файл - не программа для мозговых ошибок, это программа на javascript, которая содержит программу для мозговых операций, которая преобразуется в javascript во время выполнения.
подземный
3
Ну --iбыстрее чем i--? Кажется ложным с годами: jsperf.com/decrementgolf .
Майкл М.
4
Это не только очень креативная подача на конкурс, но и очень четкое объяснение синтаксиса мозгового эффекта. +10 если бы я мог!
СебастьянH
74

Я думаю, блестящий Леннарт Огюсссон уже дважды выиграл это.

Во-первых, вот пример его реализации BASIC «хак выходного дня» в качестве Haskell Monadic DSL, начиная с 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

Работает, перегружая тип номера. Номера строк на самом деле являются функциями, которые принимают аргументы. Остальная часть строки - аргументы функции. Функция возвращает представление абстрактного синтаксического дерева для интерпретатора BASIC, чтобы продолжить работу.

Я также рекомендую вам проверить участие Огюсссона в 2006 году в Международном конкурсе обфусцированных Си, в котором ему удалось втиснуться в 4k:

  • Интерпретатор байт-кода, написанный в подмножестве C (который он называет Obfuscated C).
  • Запутанный C -> байткод компилятор, написанный в байткоде.

Они могут использовать один и тот же файл, потому что байт-код находится внутри комментариев C.

Прошло несколько лет с тех пор, как я следил за работой Огюсссона, поэтому с тех пор, возможно, у него появятся и другие блестящие вещи ...

оборота Питару
источник
2
Это Огюстсон, а не Огюссен.
Ганс Лундмарк,
@ HansLundmark Спасибо. Починил это.
Питару
71

PHP и Javascript

Это полиглот:

Вы можете запустить этот код на обоих языках:

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

Хитрость в том, что Javascript использует escape-последовательности в строках, начинающихся с 'и ".
С другой стороны, PHP использует escape-последовательности только в строках, начинающихся с "и <<<.

Затем мы объявляем функцию printf, которая похожа на, printно выводит форматированную строку в PHP.

PHP требует, чтобы vars начинался с $, а Javascript просто позволяет.

Исмаэль Мигель
источник
Никто не использует Array(…)в JS, и это явно array(…)в PHP. […]было бы намного лучше;)!
Blackhole
12
Мне все равно, используют ли люди Array()в JS или нет: мне важно, чтобы у меня был ИСТИННЫЙ полиглот. Делаю один из худших преступлений JS с этим кодом , но все , что я хочу, что он работает и делает точно то же самое в обоих, но , глядя , как JS и PHP в то же время.
Исмаэль Мигель
И, кстати, [...]недопустимо в PHP <5.4.0, что плохо ....... Если я добавлю это в PHP 4, 5 или Javascript, я ожидаю, что это будет работать, вместо того, чтобы давать синтаксические ошибки везде.
Исмаэль Мигель
2
Если вы хотите, чтобы ваш код выглядел как JS, вы должны использовать […], что кажется довольно стандартным в PHP, и, следовательно, подходит для вашей цели. И, кстати, PHP <5.4? Время обновлять, парень ...
Blackhole
8
Совместимость важнее, чем «внешность». И Arrayэто ПРАВИЛЬНОЕ имя конструктора объекта Array. В основном, использование так []же, как Array(). Я не вижу в этом ничего плохого. Но у меня есть один простой вопрос: работает? (Кстати, я должен использовать php 5.3.28 на работе.)
Исмаэль Мигель
55

Brainfuck в JS

[][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[
!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[
+!+[]]]]][([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(
![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!
![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+
[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]
]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[
]+!+[]+!+[]+!+[]]]]+([][[]]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+[]+!+[]]]]+(!!
[]+[])[+[[+[]]]]+(!![]+[])[+[[+!+[]]]]+([][[]]+[])[+[[+[]]]]+([][(![]+[])[+[[
+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!
![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+
[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[
[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!!
[]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+[])[+[[!+[]+!+[]+!+[]+!+[]
+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]((![]+[])[+[[+!+[]]]]+(![]+[])[+[[!+[]+!+
[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]+(!![]+[])[+[[+[]]]
]+([][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[
+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[
+[[+!+[]]]]]+[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+[+!+[]]+([][(![]+[]
)[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]
]]+(!![]+[])[+[[+[]]]]+(!![]+[])[+[[!+[]+!+[]+!+[]]]]+(!![]+[])[+[[+!+[]]]]]+
[])[+[[+!+[]]]+[[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]]])()
Клайд Лобо
источник
12
Я не вижу здесь никакого бреда. Не было даже одного символа><,.-
Майкл М.
8
@ Майкл: Кто сказал, что это не программа, которая делает бесконечный цикл?
Конрад Боровски
19
это JSF * ск?
8
Как на земле это делает это ?
nandhp
4
Оо. Кто-то наконец сделал это. Я потратил некоторое время, пытаясь понять, как написать программу на JS, используя только символы +! [] (), Но так и не смог понять это. Мне нужно проанализировать это, когда у меня будет время ...
Матти Вирккунен
54

Это один из победителей IOCCC 2005 года , программа на C, которая, за исключением этого набора определений, выглядит как 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]);
    }

}
Виктор
источник
3
Многословие во всей красе.
qwr
39

C ++ в C

Итак, вы программист на C ++, но вынуждены использовать C? Нет проблем, вам просто нужно написать несколько дополнительных заголовков, отсутствующих в C. Например, вот действующая программа Hello World на C:

В дополнительном заголовочном файле iostreamнапишите:

#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

В файле stringнапишите

#define string

В файле helloworld.c(ваш фактический код C), напишите

#include <iostream>
#include <string>

using namespace std;

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

И при компиляции helloworld.cс компилятором, проинструктировать компилятор также искать <...>файлы заголовков , где вы сохранили файлы , iostreamи string, например, если вы компиляции с GCC и поместить файлы iostreamи stringв текущем каталоге, компилировать с

gcc helloworld.c -o helloworld -I.

Примечание. volatileЗаголовок in iostreamпредназначен для включения компиляции без предупреждений даже на максимальном уровне предупреждения (считается, что чтение из энергозависимой переменной имеет эффект).

celtschk
источник
3
Это немного троллинг кода, не так ли?
Мистер Листер
Ну, программа делает именно то, что кажется, не так ли?
celtschk
8
Так гораздо смешнее и впечатляюще, чем C в C ++.
Кайл Стрэнд
Какой компилятор предупреждает, если вы не используете volatileздесь, и что за предупреждение?
Р. Мартиньо Фернандес
1
@KyleStrand Но "C в C ++" больше соответствует цитате в вопросе. Настоящие программисты программируют на C, даже если у них есть компилятор C ++.
Мистер Листер
36

CQL - язык запросов с кофеином

(или «SQL на кофеин»)

Это могло быть несколько чрезмерно амбициозным. Вот попытка написать декларативный код SQL (ish) в CoffeeScript . Для этого требуется функция прокси ECMAScript 6 . Вы можете проверить это в узле с --harmony-proxies.

Давайте настроим шаблон для определения прокси. (Взято из комментария Бенви по этому вопросу )

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

Теперь определите прокси-объект и некоторые подозрительные глобальные переменные и функции:

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

Ну, это было довольно много настроек! Но теперь мы можем сделать следующее (ввод / вывод в стиле консоли):

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

Это не настоящий полиглот, но не в этом дело. Я знаю, что @это используется для переменных в SQL, но мне нужны все @s для имен столбцов и таблиц, потому что я не нашел способа проксировать глобальный объект (и я не удивлюсь, если это действительно невозможно - и для веская причина).

Я также изменил некоторые скобки в скобках (в частности, после VALUESи IN). К сожалению, я вообще не смог понять, как можно разрешить нормальные условные выражения year > 2000, потому что они сразу вычислились бы как логические.

Тем не менее, это очень похоже на SQL и определенно более декларативно, чем императивно / функционально / объектно-ориентировано, поэтому оно должно хорошо подходить для вопроса. Я на самом деле думаю, что если я немного отполирую код и поддержу еще несколько функций, это может быть полезным модулем CoffeeScript.

Во всяком случае, это было весело! :)

Для тех, кто не слишком знаком с CoffeeScript, запросы SQL компилируются в следующий 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)));
});
Мартин Эндер
источник
Это довольно много настроек, но выглядит хорошо. Я не программист CoffeeScript, но это выглядит великолепно. В @SQL используется для переменных сеанса.
Исмаэль Мигель
Я решил сделать ключевые слова глобальными сейчас. Теперь есть только @s для имен столбцов и таблиц.
Мартин Эндер
Теперь это очень похоже на SQL! Вы сделали хорошую работу с этим!
Исмаэль Мигель
1
Мне плевать на кофе, но это круто.
KRyan
2
@ спасибо спасибо, но нет, я просто взломал это вместе для этого вызова. Забавное совпадение: переделывать это аккуратно и помещать в GitHub было в моем списке потенциальных / долгосрочных проектов кодирования, пока я не удалил его только этим утром.
Мартин Эндер
27

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

Это также работает в VBScript.

зубная щетка
источник
1
Умная. Вам даже не нужно большинство точек с запятой.
js1568
@ js1568 Спасибо! Я теперь удалил точки с запятой, которые не нужны.
Зубная щетка
20

F # в C ++

Скорее не воображаемое и противное злоупотребление препроцессором. Я подумал, что было бы интересно изменить C ++, чтобы он выглядел как совершенно другой язык, вместо того, чтобы использовать несколько псевдонимов, чтобы он выглядел как Java или PHP. Я не ожидаю, что это соберет кучу голосов, это просто ради забавы.

#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

Попробуй это здесь .

К сожалению, что-то написать в STDOUT - это почти все, что он может сделать, хотя я уверен, что если кто-то бросит в него достаточно колдовства, он сможет заставить его делать больше.

Тони Эллис
источник
2
Чтобы последняя строка работала в F #, она должна быть exit 0или просто 0.
Jwosty
20

Python и ... никто не догадается (править: dc)

Вот некоторый допустимый код Python, но на самом деле программа написана на совершенно другом языке:

# 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

Код работает на обоих языках без ошибок.

Комбинация очень сумасшедшая; Я был бы рад подождать один или два дня, прежде чем сказать, какой другой язык; пожалуйста, оставьте комментарии для угадывания.

редактировать: язык был основанный на стеке язык от dc. Вы можете увидеть здесь хорошо известные ключевые слова , как for, if, or, in, но только буквы значения! Значение, ,которое не имеет значения в dc, превращается в регистр, потому что в первый раз оно появляется после буквы s(то же самое для :).

Томас Барухель
источник
1
Если код не делает одно и то же на обоих языках, я полагаю, что такой язык, как Befunge, мог бы сработать.
Томас Эдинг
ОК, я редактирую код, чтобы поставить язык, который я выбрал.
Томас Барухель
18

C ++ позволяет писать код, похожий на lisp, с помощью библиотеки 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();

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

informatimago
источник
4
Добро пожаловать! Мы просим пользователей пометить свои сообщения как вики-сообщество, если ответ не является их собственной работой. (И дать надлежащую атрибуцию, но вы уже сделали это, так что спасибо!)
Джонатан Ван Матре
Оригинал или нет, вы получили мой голос :)
itsjeyd
15

C # в пробелах

Хорошо, сначала попробуйте один из них, так что давайте посмотрим, как это происходит. 

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!

И в случае, если форматирование пошло не так из-за необходимости помещать четыре пробела в начале каждой строки, здесь снова. для пробела и # для табуляции:

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!
Роджер
источник
12

HTML и CSS

Не языки программирования, но ... этот документ является действительным HTML и CSS:

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

Это работает, потому что HTML-комментарии разрешены в таблицах стилей по историческим причинам. Да, и каждый действительный HTML-документ также является допустимой программой PHP, так что это тоже PHP . :)

Fuxia
источник
2
Это довольно забавно и все, но это не проблема полиглота .
Мартин Эндер
Поскольку CSS можно считать завершенным , это может быть правильным ответом.
Адам Дэвис
2
HTML и CSS не являются языками программирования :)
Jet
9

C в Скала

Промежуточный слой эмулирует более романтичную эпоху, когда строки все еще были массивами байтов с нулевым символом в конце. 

// 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
источник
"This program does not take parameters!"одурачить тебя
Эрик Outgolfer
8

сед и апл

Мой босс хочет, чтобы я писал сценарии sed, но я предпочитаю писать APL весь день. Тем не менее, он очень доволен моей работой, потому что такие сценарии отлично работают с его версией sed:

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

Вы можете попробовать это на моем новом сайте с этой постоянной ссылкой . Это скомпилированная для JavaScript версия GNU APL. Окончательный выпуск будет позже с официальным выпуском GNU APL, v. 1.3, но вы можете отлично использовать его для своих постоянных ссылок, если вам нравится GNU APL.

Томас Барухель
источник
7

С в Хаскеле

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

Конечно, поскольку cmainничего не делает с argcили argv, код маршалинга аргументов не имеет никакого эффекта, и, поскольку он cmainвсегда возвращает 0, ветвь else в операторе if мертва. Но утверждение «если» все равно ничего не делает.

Все фигурные скобки и точки с запятой не нужны, как и большинство скобок и некоторые doключевые слова. Заявление «если» могло быть записано как if exitCode == 0 then exitWith ExitSuccess else exitWith (ExitFailure (fromIntegral exitCode)).

Таннер Светт
источник
7

C ++ в Forth

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

Не самое гибкое решение, но оно работает, если написано точно так, как показано.

Майкл
источник
7

Haskell на Java

(«ванильная» Java 7, а не Java 8) (Да, я знаю, что бокс снижает производительность; даже попытка использовать функции более высокого порядка сводит с ума многословно: D)

У Java очень жесткий синтаксис, поэтому вместо изменения синтаксиса я попытался сделать код семантически более похожим на стиль в Haskell.

Редактировать - добавлена ​​частичная функция приложения.

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

(Да, все, что делает это безумие, это вычисления 6!)

Сардж Борщ
источник
6

КОБОЛ в АУК

В духе цитаты. Чистый, незапятнанный AWK, как его может написать программист на языке COBOL.

Задача - подсчитать записи в файле. Эта ранняя версия разработки рассчитывает на тестирование. Правильный файл будет жестко запрограммирован позже, когда выйдет из модульного тестирования ...

Если бы я мог заставить подсветку синтаксиса делать фосфоресцентно-зеленый на черном, было бы здорово ...

Даже в этом случае правильные номера столбцов, это семь пробелов в начале каждой строки (никогда не делали этого в awk раньше) и разрывы длинных операторов печати в столбце 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 
   }
Билл Вуджер
источник
6

Brainfuck (или что-нибудь еще) в Racket

Гибкий модуль Racket и система макросов позволяют ему реализовать поддержку модулей для совершенно новых языков, как доменных, так и общего назначения. Для Datalog и Algol 60 имеется встроенная поддержка , поэтому следующие действительные программы 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

Вы также можете добавить поддержку для других языков: например, см . Описание Danny Yoo о том, как реализовать поддержку Brainfuck, которая разрешает такие программы для Racket, как:

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

А так как поддержка добавлена ​​на уровне скомпилированного модуля, можно связать модули, написанные на разных языках, или встроить фрагмент одного языка в модуль, написанный на другом.

Ури Зарфаты
источник
5

SML на Java

У меня все еще есть какой-то древний код, когда я начал изучать Java и пытался использовать его в функциональном стиле. Слегка вымыто:

/**
 * 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));
    }
}
Питер Тейлор
источник
5

Java в Perl

Может считаться нарушением правил, но мне все равно. Очевидно, что он должен выглядеть как Java-программа. Он печатает 20 чисел Фибоначчи, если это не очевидно.

Требуется модуль Inline :: Java для установки.

use Inline Java => <<'JAVA';
/**
 * @author  Konrad Borowski <x.fix@o2.pl>
 * @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();
Конрад Боровски
источник
4

J и ... никто не догадается (править: dc)

Это моя вторая запись; Вот фрагмент правильного кода J, который возвращает 1:

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

Я жду один или два дня, прежде чем сказать, какой другой язык выполняет тот же кусок кода без ошибок. Просто оставьте комментарии за попытку угадать.

редактировать: другой язык является языком стека из очень древнего калькулятора Unix DC.

Томас Барухель
источник
3
Он работает без ошибок в GolfScript, BF, HQ9 +, ...
Питер Тейлор
Хорошо, я не знал, что такое множество языков может это сделать. Я редактирую код, чтобы поставить язык, который я выбрал.
Томас Барухель
@ ברוכאל на этих языках он работает без ошибок, потому что в этих языках нет ошибок или нет ошибок, применимых к этому коду. Например. Brainfuck игнорирует все символы, которых нет, .,+-<>[]поэтому ваша программа эквивалентна ...[.]+in brainfuck, которая является допустимой, но бессмысленной программой. AFAIK программа «бредфук» может быть недействительной только из-за несоответствия [].
immibis
@immibis. Это неверно dc - старый калькулятор, и я могу заверить, что изменение одной вещи в моих кодах вызовет ошибку. Я потратил много времени на некоторые части кода, чтобы найти хитрый способ расстановки букв в правильном порядке. Мой кусок кода Postscript / dc довольно экстремальный: нет ошибок, но изменение чего-либо сделает его неисправным. dc не имеет ничего общего с "этими языками"; dc примерно на 20 или 30 лет старше, чем "эти языки"; он обычно устанавливается в любом дистрибутиве Linux. Пожалуйста, просмотрите немного, если вы еще не слышали об этом.
Томас Барухель
1
@ ברוכאל Вы неправильно поняли - я говорил о бреду, HQ9 +, гольскрипте и т. Д., А не о dc.
immibis
4

DC работает с файлом PostScript

dc может выполнить следующий фрагмент кода без ошибок:

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
Томас Барухель
источник
3

ML / (Строгий) Haskell в Java

Это из реального реального проекта. Он использует постоянные неизменяемые структуры данных и использует рекурсию, даже когда в этом нет необходимости. На самом деле это больше похоже на Kore (язык, реализуемый проектом) в Java, но стиль в основном такой же, как и в ML. Но философия Kore заключается в том, что автор не должен форматировать свой код, поэтому ни один из кодов Java также не форматируется (он автоматически форматируется с помощью eclipse).

удалить n элементов из списка :

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

В ML / Haskell, где вы будете использовать шаблон для извлечения головы и хвоста, здесь вы говорите list.cons().xи list.cons().tail.

вставить элемент в список :

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

Список определяется буквально так, как будет определяться алгебраический тип данных. Вот версия с удаленным шаблоном, сгенерированным затмением:

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

Вот структура данных карты, реализованная в виде дерева :

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

Типы начинают занимать столько же места, сколько и код. Например, в путах , метод имеет 302 символов типов и 343 символов коды (не считая пространства / перевода строки).

Собака
источник
2

Бейсик в рубине

Реализовано это давно. Источник находится на GitHub . Вдохновленный подобной вещью в Scala

Настроить

#!/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__)

Бейсик код

#!./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
источник
2

Haskell в шаблонах C ++

Я сделал это FizzBuzz в C ++ шаблонах несколько месяцев назад на жаворонке. Это в значительной степени реализация следующего кода на Haskell, все в шаблонах C ++. Фактически, даже целочисленная арифметика переопределяется на уровне типов - обратите внимание, что ни один из шаблонов не использует параметры int!

Код на 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..]

и версия метапрограммирования шаблона C ++:

//  
//  Lazy compile-time fizzbuzz computed by C++ templates,
//  without conditionals or the use of machine arithmetic.
//
//         -- Matt Noonan (mnoonan@grammatech.com)

#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;
}
Мэтт Нунан
источник