python fizzbuzz

condensed.py

((lambda reclimit: lambda F: lambda compose: lambda cons: lambda fix: lambda
ident: lambda nil: lambda pair: lambda succ: lambda zero: (lambda add: lambda
append: lambda enumTo: lambda fmap: lambda foldr: lambda getInt: lambda
getList: lambda intersperse: lambda makeInt: lambda makeList: lambda sub:
((lambda divMod: lambda getChar: lambda makeChar: (lambda mod: lambda
makeString: lambda intercalate: lambda getString: (lambda fizzbuzzTest: lambda
showInt: (lambda fizzbuzz3: lambda fizzbuzz5: lambda n:
print(getString(intercalate(makeString("\n")) (fmap(lambda n:
F.get(compose(fizzbuzz3(n)) (fizzbuzz5(n)) (ident) (F(lambda: showInt(n)))))
(enumTo(makeInt(n))))))) (fizzbuzzTest(makeInt(3)) (makeString("fizz")))
(fizzbuzzTest(makeInt(5)) (makeString("buzz")))) (lambda m: lambda s: lambda n:
lambda x: lambda v: F.get(mod(n) (m) (F(lambda: append(s) (x(nil)))) (lambda _:
x(v)))) (lambda n: n(makeString("0")) (lambda _: fix(lambda rec: lambda n:
lambda rs: n(rs) (lambda _: divMod(n) (makeInt(10)) (lambda d: lambda m: rec(d)
(cons(add(m) (makeInt(ord('0')))) (rs))))) (n) (nil)))) (lambda x: lambda y:
divMod(x) (y) (lambda d: lambda m: m)) (lambda xs: makeList([makeChar(x) for x
in xs])) (lambda xs: lambda yss: foldr(append) (nil) (intersperse(xs) (yss)))
(lambda xs: ''.join(map(getChar, getList(xs))))) (lambda x: lambda y: y(pair(y)
(y)) (lambda y1: fix(lambda rec: lambda a: lambda b: F.get(a(F(lambda:
pair(zero) (sub(y1) (b)))) (lambda a1: rec(a1) (b(y1) (ident)) (lambda d:
lambda m: pair(b(succ(d)) (lambda _: d)) (m))))) (x) (y1))) (lambda x:
chr(getInt(x))) (lambda x: makeInt(ord(x))))) (fix(lambda rec: lambda x: lambda
y: x(y) (lambda x1: succ(rec(x1) (y))))) (fix(lambda rec: lambda xs: lambda ys:
xs(ys) (lambda x: lambda xs1: cons(x) (rec(xs1) (ys))))) (fix(lambda rec:
lambda rs: lambda x: x(cons(x) (rs)) (lambda x1: rec(cons(x) (rs)) (x1)))
(nil)) (fix(lambda rec: lambda f: lambda xs: xs(xs) (lambda x: lambda xs1:
cons(f(x)) (rec(f) (xs1))))) (fix(lambda rec: lambda f: lambda z: lambda xs:
xs(z) (lambda x: lambda xs1: F.get(f(x) (F(lambda: rec(f) (z) (xs1)))))))
(fix(lambda rec: lambda n: n(0) (lambda n1: 1 + rec(n1)))) (fix(lambda rec:
lambda xs, rs=None: rec(xs, []) if rs is None else xs(rs) (lambda x: lambda
xs1: [rs.append(x), rec(xs1, rs)][1]))) (lambda x: lambda ys: ys(ys) (lambda y:
lambda ys1: cons(y) (fix(lambda rec: lambda ys: ys(ys) (lambda y: lambda ys2:
cons(x) (cons(y) (rec(ys2))))) (ys1)))) (fix(lambda rec: lambda n:
succ(rec(n-1)) if n else zero)) (fix(lambda rec: lambda xs, n=0: cons(xs[n])
(rec(xs, n+1)) if n < len(xs) else nil)) (fix(lambda rec: lambda x: lambda y:
y(x) (lambda y1: x(x) (lambda x1: rec(x1) (y1))))))
(__import__('sys').setrecursionlimit(10000)) (type('F', (object,), {
'__init__': lambda self, fn: next(None for self.fn, self.ok in ((fn, False),)),
'__call__': lambda self, x: self.get(self) (x), 'get': classmethod(lambda cls,
n: n if not isinstance(n, cls) else n.fn if n.ok else next(n.fn for n.fn, n.ok
in ((n.fn(), True),)))})) (lambda f: lambda g: lambda x: f(g(x))) (lambda x:
lambda xs: lambda n: lambda c: c(x) (xs)) (lambda f: (lambda x: x(x)) (lambda
x: f(lambda *args, **kwargs: x(x) (*args, **kwargs)))) (lambda x: x) (lambda n:
lambda c: n) (lambda x: lambda y: lambda f: f(x) (y)) (lambda n: lambda z:
lambda s: s(n)) (lambda z: lambda s: z)) (100)

fizzbuzz.js

F = fn => new Proxy(Object.assign(x => fn(x), {_F: 1, _f: fn}), {
	apply: (target, self, args) => Fget(target)(...args) })

Fget = n => !n._F ? n : n._ok ? n._val :
	[n._val = n._f(null), n._ok = 1, n][2]._val

fix = f => x => f(fix(f))(x)
compose = f => g => x => f(g(x))

makeInt = fix(rec => n => n ? succ(rec(n-1)) : z => s => z)
getInt = fix(rec => n => n(0)(n1 => 1 + rec(n1)))
zero = z => s => z
succ = n => z => s => s(n)
add = x => y => x(y)(x1 => succ(add(x1)(y)))
sub = x => y => y(x)(y1 => x(x)(x1 => sub(x1)(y1)))
mod = x => y => divMod(x)(y)(d => m => m)
divMod = x => y => y(pair(y)(y))(y1 =>
	fix(rec => a => b => Fget(a
		(F(() => pair(z => s => z)(sub(y1)(b))))
		(a1 => rec(a1)(b(y1)(x => x))
			(d => m => pair(b(succ(d))(a => d))(m)))))(x)(y1))
showInt = n => n(makeString('0'))(_ =>
	fix(rec => n => rs => n(rs)(_ =>
		divMod(n)(makeInt(10))(d => m =>
			rec(d)(cons(add(m)(makeInt('0'.charCodeAt(0))))(rs)))))(n)(nil))

makeList = (xs, n=0) => n < xs.length ? cons(xs[n])(makeList(xs, n+1)) : nil
getList = (xs, rs=null) => rs === null ? getList(xs, []) :
	xs(rs)(x => xs1 => [rs.push(x), getList(xs1, rs)][1])
nil = n => c => n
cons = x => xs => n => c => c(x)(xs)
append = xs => ys => xs(ys)
	(x => xs1 => cons(x)(append(xs1)(ys)))
enumTo = fix(rec => rs => x =>
	x(cons(x)(rs))(x1 => rec(cons(x)(rs))(x1)))(nil)
fmap = f => xs => xs(xs)
	(x => xs1 => cons(f(x))(fmap(f)(xs1)))
intersperse = x => ys => ys(ys)(y => ys1 =>
	cons(y)(fix(rec => ys => ys(ys)(y => ys2 =>
		cons(x)(cons(y)(rec(ys2)))))(ys1)))
intercalate = xs => yss => concat(intersperse(xs)(yss))
foldr = f => z => xs => xs(z)(x => xs1 =>
	Fget(f(x)(F(() => foldr(f)(z)(xs1)))))
concat = foldr(append)(nil)

makeChar = x => makeInt(x.charCodeAt(0))
getChar = x => String.fromCharCode(getInt(x))
makeString = xs => makeList(Array.from(xs).map(x => makeChar(x)))
getString = xs => getList(xs).map(getChar).join('')
unlines = intercalate(makeString('\n'))

pair = x => y => f => f(x)(y)
first = p => p(x => y => x)
second = p => p(x => y => y)

fizzbuzzTest = m => s => n => x => v => Fget(
	mod(n)(m)(F(() => append(s)(cons(makeChar(' '))(x(nil)))))(_ => x(v)))
fizzbuzz3 = fizzbuzzTest(makeInt(3))(makeString('Fizz'))
fizzbuzz5 = fizzbuzzTest(makeInt(5))(makeString('Buzz'))
fizzbuzz = n => Fget(compose(fizzbuzz3(n))(fizzbuzz5(n))(x => x)(F(() => showInt(n))))

main = n => getString(fizzbuzz(makeInt(n)))

for(let i = 900; i < 1000; ++i)
	console.log(main(i))

fizzbuzz.py

import sys
sys.setrecursionlimit(10000)

class F:
	def __init__(self, fn):
		self.fn = fn
		self.ok = False
	def __call__(self, x):
		return self.get(self)(x)
	@classmethod
	def get(cls, n):
		if not isinstance(n, cls): return n
		if n.ok: return n.fn
		if callable(n.fn): n.fn = n.fn()
		n.ok = True
		return n.fn

trace = lambda *xs, **ys: print(*xs, **ys) or xs[-1]
traceWith = lambda f: lambda x: print(f(x)) or x

fix = lambda f: lambda x: f(fix(f))(x)
ident = lambda x: x
compose = lambda f: lambda g: lambda x: f(g(x))

makeBool = lambda x: true if x else false
getBool = lambda x: x(True)(False)
true = lambda t: lambda f: t
false = lambda t: lambda f: f
ifThenElse = ident

makeInt = lambda n: succ(makeInt(n-1)) if n else zero
getInt = lambda n: n(0)(lambda n1: 1 + getInt(n1))
zero = lambda z: lambda s: z
succ = lambda n: lambda z: lambda s: s(n)
pred = lambda n: n(n)(lambda n1: n1)
add = lambda x: lambda y: x(y)(lambda x1: succ(add(x1)(y)))
sub = lambda x: lambda y: y(x)(lambda y1: x(x)(lambda x1: sub(x1)(y1)))
mod = lambda x: lambda y: second(divMod(x)(y))
divMod = lambda x: lambda y: y(pair(y)(y))(lambda y1:
	fix(lambda rec: lambda a: lambda b: F.get(
		a(F(lambda: pair(zero)(sub(y1)(b))))
		(lambda a1: rec(a1)(b(y1)(ident))
			(lambda d: lambda m: pair(b(succ(d))(lambda _: d))(m)))))(x)(y1))
eqInt = lambda x: lambda y: x(y(true)(lambda _: false)) \
	(lambda x1: y(false)(lambda y1: eqInt(x1)(y1)))
showInt = lambda n: n(makeString("0"))(lambda _:
	fix(lambda rec: lambda n: lambda rs: n(rs)(lambda _:
		divMod(n)(makeInt(10))(lambda d: lambda m:
			rec(d)(cons(add(m)(makeInt(ord('0'))))(rs)))))(n)(nil))

makeList = lambda xs, n=0: cons(xs[n]) \
	(makeList(xs, n+1)) if n < len(xs) else nil
getList = lambda xs, rs=None: getList(xs, []) if rs is None else \
	xs(rs)(lambda x: lambda xs1: [rs.append(x), getList(xs1, rs)][1])
nil = lambda n: lambda c: n
cons = lambda x: lambda xs: lambda n: lambda c: c(x)(xs)
append = lambda xs: lambda ys: xs(ys) \
	(lambda x: lambda xs1: cons(x)(append(xs1)(ys)))
enumTo = fix(lambda rec: lambda rs: lambda x:
	x(cons(x)(rs))(lambda x1: rec(cons(x)(rs))(x1)))(nil)
fmap = lambda f: lambda xs: xs(xs) \
	(lambda x: lambda xs1: cons(f(x))(fmap(f)(xs1)))
intersperse = lambda x: lambda ys: ys(ys)(lambda y: lambda ys1:
	cons(y)(fix(lambda rec: lambda ys: ys(ys)(lambda y: lambda ys2:
		cons(x)(cons(y)(rec(ys2)))))(ys1)))
intercalate = lambda xs: lambda yss: concat(intersperse(xs)(yss))
foldr = lambda f: lambda z: lambda xs: xs(z)(lambda x: lambda xs1:
	F.get(f(x)(F(lambda: foldr(f)(z)(xs1)))))
concat = foldr(append)(nil)

makeChar = lambda x: makeInt(ord(x))
getChar = lambda x: chr(getInt(x))
makeString = lambda xs: makeList([makeChar(x) for x in xs])
getString = lambda xs: ''.join(map(getChar, getList(xs)))
unlines = intercalate(makeString("\n"))

either = ident
left = lambda x: lambda l: lambda r: l(x)
right = lambda x: lambda l: lambda r: r(x)

makePair = lambda x, y: pair(x)(y)
getPair = lambda p: p(lambda x: lambda y: (x, y))
pair = lambda x: lambda y: lambda f: f(x)(y)
first = lambda p: p(lambda x: lambda y: x)
second = lambda p: p(lambda x: lambda y: y)

fizzbuzzTest = lambda m: lambda s: lambda n: lambda x: lambda v: F.get(
	mod(n)(m)(F(lambda: append(s)(x(nil))))(lambda _: x(v)))
fizzbuzz3 = fizzbuzzTest(makeInt(3))(makeString("fizz"))
fizzbuzz5 = fizzbuzzTest(makeInt(5))(makeString("buzz"))
fizzbuzz = lambda n: F.get(
	compose(fizzbuzz3(n))(fizzbuzz5(n))(ident)(F(lambda: showInt(n))))

main = lambda n: print(getString(unlines(fmap(fizzbuzz)(enumTo(makeInt(n))))))

main(100)