sforman/Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Blacken the code (simplejoy.py)

Browse Source 
I don't like it entirely but that's the point: nevermind your taste,
just use a simple and universal (Ha!) standard format(ter) and get on
with your life.
This commit is contained in:
Simon Forman
2022-09-07 09:41:08 -07:00
parent d6818620e3
commit be13b72d93
1 changed files with 93 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
implementations/Python/simplejoy.py
+85 -45
View File
@@ -37,10 +37,20 @@ import operator
JOY_BOOL_LITERALS = 'false', 'true'
class NotAListError(Exception): pass
class NotAnIntError(Exception): pass
class StackUnderflowError(Exception): pass
class UnknownSymbolError(KeyError): pass
class NotAListError(Exception):
pass
class NotAnIntError(Exception):
pass
class StackUnderflowError(Exception):
pass
class UnknownSymbolError(KeyError):
pass
'''
@@ -102,18 +112,21 @@ WORDS = (
'\]' # right square bracket (escaped so it doesn't close the character class)
'\s' # nor blankspace
']+' # end character class, one-or-more.
)
)
token_scanner = Scanner([
token_scanner = Scanner(
[
(BRACKETS, lambda _, token: token),
(BLANKS, None),
(WORDS, lambda _, token: token),
])
]
)
class Symbol(str):
'''A string class that represents Joy function names.'''
__repr__ = str.__str__
@@ -163,17 +176,23 @@ def _parse(tokens):
frame = []
elif tok == ']':
v = frame
try: frame = stack.pop()
try:
frame = stack.pop()
except IndexError:
raise ParseError('Extra closing bracket.') from None
frame.append(list_to_stack(v))
elif tok == 'true': frame.append(True)
elif tok == 'false': frame.append(False)
elif tok == 'true':
frame.append(True)
elif tok == 'false':
frame.append(False)
else:
try: thing = int(tok)
except ValueError: thing = Symbol(tok)
try:
thing = int(tok)
except ValueError:
thing = Symbol(tok)
frame.append(thing)
if stack: raise ParseError('Unclosed bracket.')
if stack:
raise ParseError('Unclosed bracket.')
return list_to_stack(frame)
@@ -230,11 +249,11 @@ def concat(quote, expression):
# on quotes longer than sys.getrecursionlimit().
# :raises RuntimeError: if quote is larger than sys.getrecursionlimit().
## return (quote[0], concat(quote[1], expression)) if quote else expression
## return (quote[0], concat(quote[1], expression)) if quote else expression
# Original implementation.
## return list_to_stack(list(iter_stack(quote)), expression)
## return list_to_stack(list(iter_stack(quote)), expression)
# In-lining is slightly faster (and won't break the
# recursion limit on long quotes.)
@@ -259,6 +278,7 @@ def concat(quote, expression):
╚═╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝
'''
def stack_to_string(stack):
'''
Return a "pretty print" string for a stack.
@@ -289,12 +309,18 @@ def expression_to_string(expression):
def _joy_repr(thing):
return JOY_BOOL_LITERALS[thing] if isinstance(thing, bool) else repr(thing)
return (
JOY_BOOL_LITERALS[thing]
if isinstance(thing, bool)
else repr(thing)
)
def _to_string(stack, f):
if not isinstance(stack, tuple): return _joy_repr(stack)
if not stack: return '' # shortcut
if not isinstance(stack, tuple):
return _joy_repr(stack)
if not stack:
return '' # shortcut
return ' '.join(map(_s, f(stack)))
@@ -302,7 +328,7 @@ _s = lambda s: (
'[%s]' % expression_to_string(s)
if isinstance(s, tuple)
else _joy_repr(s)
)
)
'''
@@ -382,9 +408,11 @@ def initialize():
def SimpleFunctionWrapper(f):
'''Wrap functions that take and return just a stack.'''
@wraps(f)
def inner(stack, expr, dictionary):
return f(stack), expr, dictionary
return inner
@@ -404,18 +432,22 @@ def branch(stack, expr, dictionary):
do = then if flag else else_
return stack, concat(do, expr), dictionary
@inscribe
def dip(stack, expr, dictionary):
quote, (x, stack) = stack
return stack, concat(quote, (x, expr)), dictionary
@inscribe
def i(stack, expr, dictionary):
quote, stack = stack
return stack, concat(quote, expr), dictionary
LOOP = Symbol('loop')
@inscribe
def loop(stack, expr, dictionary):
quote, (flag, stack) = stack
@@ -439,53 +471,62 @@ def loop(stack, expr, dictionary):
def clear(stack):
return ()
@inscribe
@SimpleFunctionWrapper
def concat_(stack):
(tos, (second, stack)) = stack
return concat(second, tos), stack
@inscribe
@SimpleFunctionWrapper
def cons(stack):
s0, (a1, stack) = stack
return ((a1, s0), stack)
@inscribe
@SimpleFunctionWrapper
def dup(stack):
(a1, s23) = stack
return (a1, (a1, s23))
@inscribe
@SimpleFunctionWrapper
def first(stack):
((a1, s1), s23) = stack
return (a1, s23)
@inscribe
@SimpleFunctionWrapper
def pop(stack):
(_, s23) = stack
return s23
@inscribe
@SimpleFunctionWrapper
def rest(stack):
(_, s1), stack = stack
return (s1, stack)
@inscribe
@SimpleFunctionWrapper
def stack(stack):
return stack, stack
@inscribe
@SimpleFunctionWrapper
def swaack(stack):
(s1, s0) = stack
return (s0, s1)
@inscribe
@SimpleFunctionWrapper
def swap(stack):
@@ -497,60 +538,59 @@ def BinaryFunc(f):
'''
Wrap functions that take two arguments and return a single result.
'''
@wraps(f)
def inner(stack, expression, dictionary):
(a, (b, stack)) = stack
result = f(b, a)
return (result, stack), expression, dictionary
return inner
def UnaryBuiltinWrapper(f):
'''
Wrap functions that take one argument and return a single result.
'''
@wraps(f)
def inner(stack, expression, dictionary):
(a, stack) = stack
result = f(a)
return (result, stack), expression, dictionary
return inner
for F in (
'''
██████╗ ██████╗ ███╗ ███╗██████╗ █████╗ ██████╗ ██╗███████╗██╗ ██████╗ ███╗ ██╗
██╔════╝██╔═══██╗████╗ ████║██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██║██╔═══██╗████╗ ██║
██║ ██║ ██║██╔████╔██║██████╔╝███████║██████╔╝██║███████╗██║██║ ██║██╔██╗ ██║
██║ ██║ ██║██║╚██╔╝██║██╔═══╝ ██╔══██║██╔══██╗██║╚════██║██║██║ ██║██║╚██╗██║
╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ██║ ██║██║ ██║██║███████║██║╚██████╔╝██║ ╚████║
╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚══════╝╚═╝ ╚═════╝ ╚═╝ ╚═══╝
'''
## ██████╗ ██████╗ ███╗ ███╗██████╗ █████╗ ██████╗ ██╗███████╗██╗ ██████╗ ███╗ ██╗
##██╔════╝██╔═══██╗████╗ ████║██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██║██╔═══██╗████╗ ██║
##██║ ██║ ██║██╔████╔██║██████╔╝███████║██████╔╝██║███████╗██║██║ ██║██╔██╗ ██║
##██║ ██║ ██║██║╚██╔╝██║██╔═══╝ ██╔══██║██╔══██╗██║╚════██║██║██║ ██║██║╚██╗██║
##╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ██║ ██║██║ ██║██║███████║██║╚██████╔╝██║ ╚████║
## ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚══════╝╚═╝ ╚═════╝ ╚═╝ ╚═══╝
BinaryFunc(operator.eq),
BinaryFunc(operator.ge),
BinaryFunc(operator.gt),
BinaryFunc(operator.le),
BinaryFunc(operator.lt),
BinaryFunc(operator.ne),
'''
██╗ ██████╗ ██████╗ ██╗ ██████╗
██║ ██╔═══██╗██╔════╝ ██║██╔════╝
██║ ██║ ██║██║ ███╗██║██║
██║ ██║ ██║██║ ██║██║██║
███████╗╚██████╔╝╚██████╔╝██║╚██████╗
╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═════╝
'''
##██╗ ██████╗ ██████╗ ██╗ ██████╗
##██║ ██╔═══██╗██╔════╝ ██║██╔════╝
##██║ ██║ ██║██║ ███╗██║██║
##██║ ██║ ██║██║ ██║██║██║
##███████╗╚██████╔╝╚██████╔╝██║╚██████╗
##╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═════╝
BinaryFunc(operator.xor),
BinaryFunc(operator.and_),
BinaryFunc(operator.or_),
UnaryBuiltinWrapper(operator.not_),
'''
███╗ ███╗ █████╗ ████████╗██╗ ██╗
████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██╔████╔██║███████║ ██║ ███████║
██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
'''
##███╗ ███╗ █████╗ ████████╗██╗ ██╗
##████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
##██╔████╔██║███████║ ██║ ███████║
##██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
##██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
##╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
BinaryFunc(operator.lshift),
BinaryFunc(operator.rshift),
BinaryFunc(operator.add),
@@ -562,7 +602,7 @@ for F in (
UnaryBuiltinWrapper(abs),
UnaryBuiltinWrapper(bool),
UnaryBuiltinWrapper(operator.neg),
):
):
inscribe(F)
@@ -577,7 +617,6 @@ for F in (
class Def(object):
def __init__(self, name, body):
self.__name__ = name
self.body = tuple(iter_stack(body))
@@ -595,6 +634,7 @@ class Def(object):
if name not in dictionary:
inscribe(class_(name, body), dictionary)
DEFS = '''\
-- 1 -
? dup bool