227 lines
4.9 KiB
Python
227 lines
4.9 KiB
Python
'''
|
|
In order to debug the problem I'm having with definitions breaking a
|
|
zipper expression I need to load a system, load the defs into a dictionary,
|
|
and then run the expression and see if it raises an exception, substituting
|
|
definitions one-at-a-time until I find the one that breaks it.
|
|
'''
|
|
|
|
from joy.library import default_defs, initialize, inscribe, Def
|
|
from joy.joy import joy
|
|
from joy.parser import text_to_expression
|
|
from joy.utils.pretty_print import trace
|
|
from joy.utils.stack import stack_to_string
|
|
|
|
|
|
inscribe(trace)
|
|
|
|
dictionary = initialize()
|
|
|
|
defs = {}
|
|
default_defs(defs)
|
|
|
|
|
|
expression = text_to_expression(
|
|
'[1 [2 [3 4 25 6] 7] 8]'
|
|
'[dup mul]'
|
|
'[dip dip infra dip infra dip infra]'
|
|
## '[[] ccons] step i'
|
|
|
|
# to trace replace last line above with:
|
|
'[[[] ccons] step i]'
|
|
'trace'
|
|
)
|
|
|
|
expected_result = '[1 [2 [3 4 625 6] 7] 8]'
|
|
expected_result_as_stack = text_to_expression(expected_result)
|
|
|
|
|
|
def test_expr(ds, e=expression):
|
|
'''
|
|
Run the test expression with the defs in ds.
|
|
Return the resulting stack as a string or the
|
|
exception raised if any.
|
|
'''
|
|
D = dictionary.copy()
|
|
D.update(ds)
|
|
try:
|
|
stack, _, _ = joy((), e, D)
|
|
except Exception as err:
|
|
return err
|
|
return stack_to_string(stack)
|
|
|
|
|
|
# The problem is that it works with the built-ins:
|
|
|
|
##print(test_expr({}))
|
|
|
|
# Results:
|
|
# [1 [2 [3 4 625 6] 7] 8]
|
|
#
|
|
# But not with the definitions:
|
|
|
|
##print(test_expr(defs))
|
|
|
|
# Results:
|
|
# not enough values to unpack (expected 2, got 0)
|
|
#
|
|
# This obviously sucks and is bad. :(
|
|
|
|
# First, because it's easy, let's try adding single defs
|
|
# one-at-a-time to the dictionary and see if any one of
|
|
# them breaks it.
|
|
|
|
# Only the defs that shadow the built-ins could be the problem:
|
|
candidates = set(dictionary) & set(defs)
|
|
|
|
##for def_name in candidates:
|
|
## stack_str = test_expr({def_name: defs[def_name]})
|
|
## if stack_str != expected_result:
|
|
## print(def_name, 'failed!')
|
|
## print(stack_str)
|
|
|
|
# Results:
|
|
# step failed!
|
|
# _step0
|
|
|
|
# Ah yes, step's definition has parts (and dependencies).
|
|
step_defs = {
|
|
d: defs[d]
|
|
for d in defs
|
|
if 'step' in d
|
|
}
|
|
for name in ('?', 'dupdipd', 'popopop'):
|
|
step_defs[name] = defs[name]
|
|
##print(sorted(step_defs))
|
|
##print(test_expr(step_defs))
|
|
|
|
# Results:
|
|
# [1 [2 [3 4 625 6] 7] 8]
|
|
#
|
|
# So it's not step by itself, it's some combination of defintions
|
|
# that is causing the bug.
|
|
|
|
its_is_probably_not = set('''
|
|
dipd roll< uncons
|
|
'''.split())
|
|
|
|
sus_defs = {
|
|
def_name: defs[def_name]
|
|
for def_name in defs
|
|
if (def_name in candidates
|
|
or def_name in step_defs)
|
|
and def_name not in its_is_probably_not
|
|
}
|
|
##print()
|
|
##print(test_expr(sus_defs))
|
|
|
|
d = step_defs.copy()
|
|
d['uncons'] = defs['uncons']
|
|
d['cleave'] = defs['cleave']
|
|
d['fork'] = defs['fork']
|
|
|
|
##print(test_expr(d))
|
|
|
|
CD = {
|
|
name: defs[name]
|
|
for name in candidates
|
|
}
|
|
CD.update(step_defs)
|
|
CD['codi'] = defs['codi']
|
|
CD['swapd'] = defs['swapd']
|
|
CD['cleave'] = defs['cleave']
|
|
CD['fork'] = defs['fork']
|
|
CD['grba'] = defs['grba']
|
|
CD['infrst'] = defs['infrst']
|
|
|
|
##print(test_expr(CD))
|
|
|
|
##print(sorted(CD))
|
|
# [++, --, '?', _step0, _step1, _stept, abs, app1, app2, app3, at, b, ccons, clear, 'cleave', 'codi', dipd, disenstacken, drop, dupd, dupdd, dupdip, 'dupdipd', 'fork', fourth, genrec, 'grba', ii, infra, 'infrst', map, mod, neg, not, pm, popd, popdd, popop, popopd, popopdd, 'popopop', rest, reverse, roll<, roll>, rolldown, rollup, rrest, second, shunt, step, step_zero, sum, 'swapd', swons, take, third, times, tuck, uncons, unit, unswons, x]
|
|
|
|
del CD['++']
|
|
del CD['--']
|
|
##del CD['?']
|
|
##del CD['_step0']
|
|
##del CD['_step1']
|
|
##del CD['_stept']
|
|
del CD['abs']
|
|
del CD['app1']
|
|
del CD['app2']
|
|
del CD['app3']
|
|
del CD['at']
|
|
del CD['b']
|
|
del CD['ccons']
|
|
del CD['clear']
|
|
##del CD['cleave'] # <-- dep
|
|
del CD['codi']
|
|
del CD['dipd']
|
|
del CD['disenstacken']
|
|
del CD['drop']
|
|
del CD['dupd']
|
|
del CD['dupdd']
|
|
del CD['dupdip']
|
|
del CD['dupdipd']
|
|
##del CD['fork'] # <-- dep
|
|
del CD['fourth']
|
|
del CD['genrec']
|
|
##del CD['grba'] # <-- dep
|
|
del CD['ii']
|
|
del CD['infra']
|
|
##del CD['infrst'] # <-- dep
|
|
del CD['map']
|
|
del CD['mod']
|
|
del CD['neg']
|
|
del CD['not']
|
|
del CD['pm']
|
|
del CD['popd']
|
|
##del CD['popdd'] # <-- !!!!!
|
|
del CD['popop']
|
|
del CD['popopd']
|
|
del CD['popopdd']
|
|
del CD['popopop']
|
|
del CD['rest']
|
|
del CD['reverse']
|
|
del CD['roll<']
|
|
del CD['roll>']
|
|
del CD['rolldown']
|
|
del CD['rollup']
|
|
del CD['rrest']
|
|
del CD['second']
|
|
del CD['shunt']
|
|
##del CD['step'] # <-- !!!!!
|
|
del CD['step_zero']
|
|
del CD['sum']
|
|
del CD['swapd']
|
|
del CD['swons']
|
|
del CD['take']
|
|
del CD['third']
|
|
del CD['times']
|
|
del CD['tuck']
|
|
##del CD['uncons'] # <-- popopop !?
|
|
del CD['unit']
|
|
del CD['unswons']
|
|
del CD['x']
|
|
|
|
##print(test_expr(CD))
|
|
##for n in sorted(CD):
|
|
## print(n)
|
|
## ?
|
|
## _step0
|
|
## _step1
|
|
## _stept
|
|
## cleave
|
|
## fork
|
|
## grba
|
|
## infrst
|
|
## popdd
|
|
## step
|
|
## uncons
|
|
|
|
expr = text_to_expression('[[dip]] [uncons] trace')
|
|
print(test_expr(CD, e=expr))
|
|
|
|
|
|
|
|
##print()
|
|
##print(set(dictionary) & set(defs))
|