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

Nerd Sniped

This commit is contained in:
sforman 2023-10-09 11:44:13 -07:00
parent 04d3e96a99
commit 787dc6a7b3
8 changed files with 456 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
docs/html/notebooks/NerdSnipe.html
View File

@ -138,7 +138,10 @@ sum
</code></pre> </code></pre>
<h3>≡ <code>reverse-range-++</code></h3> <h3>≡ <code>reverse-range-++</code></h3>
<p>Let's golf it a little. There is a version of <code>range</code> that generates its result list in reverse order, which would allow us to get rid of that <code>reverse</code> in the expression, and I bet we could modify that to generate them already incremented too. Let's assume we've done that already and call it <code>reverse-range-++</code>, why not?</p> <p>Let's golf it a little. There is a version of <code>range</code> that generates its result list in reverse order, which would allow us to get rid of that <code>reverse</code> in the expression, and I bet we could modify that to generate them already incremented too. Let's assume we've done that already and call it <code>reverse-range-++</code>, why not?</p>
<pre><code>[reverse-range-++ range [++] map reverse] inscribe <pre><code>reverse-range-++ == range [++] map reverse
</code></pre>
<p>See: <a href="https://joypy.osdn.io/notebooks/Recursion_Combinators.html#range-with-h4"><code>range</code> with <code>H4</code> in the Recursion Combinators notebook</a>.</p>
<pre><code>[reverse-range-++ [] swap [1 &lt;=] [pop] [[swons] dupdip --] tailrec] inscribe
</code></pre> </code></pre>
<p>Then:</p> <p>Then:</p>
<pre><code>dup size <pre><code>dup size

6
docs/source/notebooks/NerdSnipe.md
View File

@ -149,8 +149,12 @@ Let's reformat:
Let's golf it a little. There is a version of `range` that generates its result list in reverse order, which would allow us to get rid of that `reverse` in the expression, and I bet we could modify that to generate them already incremented too. Let's assume we've done that already and call it `reverse-range-++`, why not? Let's golf it a little. There is a version of `range` that generates its result list in reverse order, which would allow us to get rid of that `reverse` in the expression, and I bet we could modify that to generate them already incremented too. Let's assume we've done that already and call it `reverse-range-++`, why not?
[reverse-range-++ range [++] map reverse] inscribe reverse-range-++ == range [++] map reverse
See: [`range` with `H4` in the Recursion Combinators notebook](https://joypy.osdn.io/notebooks/Recursion_Combinators.html#range-with-h4).
[reverse-range-++ [] swap [1 <=] [pop] [[swons] dupdip --] tailrec] inscribe
Then: Then:
dup size dup size

10
implementations/C/KEYWORDS.txt
View File

@ -80,6 +80,8 @@ codi, def_codi
codireco, def_codireco codireco, def_codireco
dinfrirst, def_dinfrirst dinfrirst, def_dinfrirst
dipd, def_dipd dipd, def_dipd
dipdd, def_dipdd
dipddd, def_dipddd
disenstacken, def_disenstacken disenstacken, def_disenstacken
divmod, def_divmod divmod, def_divmod
down_to_zero, def_down_to_zero down_to_zero, def_down_to_zero
@ -89,6 +91,7 @@ dupd, def_dupd
dupdipd, def_dupdipd dupdipd, def_dupdipd
dupdip, def_dupdip dupdip, def_dupdip
enstacken, def_enstacken enstacken, def_enstacken
first_two, def_first_two
flatten, def_flatten flatten, def_flatten
fork, def_fork fork, def_fork
fourth, def_fourth fourth, def_fourth
@ -96,7 +99,6 @@ gcd, def_gcd
genrec, def_genrec genrec, def_genrec
grabN, def_grabN grabN, def_grabN
grba, def_grba grba, def_grba
hypot, def_hypot
ifte, def_ifte ifte, def_ifte
ii, def_ii ii, def_ii
infra, def_infra infra, def_infra
@ -181,4 +183,8 @@ _isnt_two_bools, def__isnt_two_bools
_\/_, def___REVERSE_SOLIDUS_SOLIDUS__ _\/_, def___REVERSE_SOLIDUS_SOLIDUS__
/\, def_SOLIDUS_REVERSE_SOLIDUS /\, def_SOLIDUS_REVERSE_SOLIDUS
\/, def_REVERSE_SOLIDUS_SOLIDUS \/, def_REVERSE_SOLIDUS_SOLIDUS
xor, def_xor _isnt_list, def__isnt_list
zip, def_zip
shift-pair, def_shift_HYPHEN_MINUS_pair
uncons-two, def_uncons_HYPHEN_MINUS_two
quote-two, def_quote_HYPHEN_MINUS_two

34
implementations/C/definitions.c
View File

@ -43,6 +43,8 @@ JoyList def_codi_body;
JoyList def_codireco_body; JoyList def_codireco_body;
JoyList def_dinfrirst_body; JoyList def_dinfrirst_body;
JoyList def_dipd_body; JoyList def_dipd_body;
JoyList def_dipdd_body;
JoyList def_dipddd_body;
JoyList def_disenstacken_body; JoyList def_disenstacken_body;
JoyList def_divmod_body; JoyList def_divmod_body;
JoyList def_down_to_zero_body; JoyList def_down_to_zero_body;
@ -52,6 +54,7 @@ JoyList def_dupd_body;
JoyList def_dupdipd_body; JoyList def_dupdipd_body;
JoyList def_dupdip_body; JoyList def_dupdip_body;
JoyList def_enstacken_body; JoyList def_enstacken_body;
JoyList def_first_two_body;
JoyList def_flatten_body; JoyList def_flatten_body;
JoyList def_fork_body; JoyList def_fork_body;
JoyList def_fourth_body; JoyList def_fourth_body;
@ -59,7 +62,6 @@ JoyList def_gcd_body;
JoyList def_genrec_body; JoyList def_genrec_body;
JoyList def_grabN_body; JoyList def_grabN_body;
JoyList def_grba_body; JoyList def_grba_body;
JoyList def_hypot_body;
JoyList def_ifte_body; JoyList def_ifte_body;
JoyList def_ii_body; JoyList def_ii_body;
JoyList def_infra_body; JoyList def_infra_body;
@ -144,7 +146,11 @@ JoyList def__isnt_two_bools_body;
JoyList def___REVERSE_SOLIDUS_SOLIDUS___body; JoyList def___REVERSE_SOLIDUS_SOLIDUS___body;
JoyList def_SOLIDUS_REVERSE_SOLIDUS_body; JoyList def_SOLIDUS_REVERSE_SOLIDUS_body;
JoyList def_REVERSE_SOLIDUS_SOLIDUS_body; JoyList def_REVERSE_SOLIDUS_SOLIDUS_body;
JoyList def_xor_body; JoyList def__isnt_list_body;
JoyList def_zip_body;
JoyList def_shift_HYPHEN_MINUS_pair_body;
JoyList def_uncons_HYPHEN_MINUS_two_body;
JoyList def_quote_HYPHEN_MINUS_two_body;
/* /*
@ -186,6 +192,8 @@ init_defs(void)
def_codireco_body = text_to_expression("codi reco"); def_codireco_body = text_to_expression("codi reco");
def_dinfrirst_body = text_to_expression("dip infrst"); def_dinfrirst_body = text_to_expression("dip infrst");
def_dipd_body = text_to_expression("[dip] codi"); def_dipd_body = text_to_expression("[dip] codi");
def_dipdd_body = text_to_expression("[dip] cons dipd");
def_dipddd_body = text_to_expression("[dipd] cons dipd");
def_disenstacken_body = text_to_expression("swaack pop"); def_disenstacken_body = text_to_expression("swaack pop");
def_divmod_body = text_to_expression("[/] [%] clop"); def_divmod_body = text_to_expression("[/] [%] clop");
def_down_to_zero_body = text_to_expression("[0 >] [dup --] while"); def_down_to_zero_body = text_to_expression("[0 >] [dup --] while");
@ -195,6 +203,7 @@ init_defs(void)
def_dupdipd_body = text_to_expression("dup dipd"); def_dupdipd_body = text_to_expression("dup dipd");
def_dupdip_body = text_to_expression("dupd dip"); def_dupdip_body = text_to_expression("dupd dip");
def_enstacken_body = text_to_expression("stack [clear] dip"); def_enstacken_body = text_to_expression("stack [clear] dip");
def_first_two_body = text_to_expression("uncons first");
def_flatten_body = text_to_expression("<{} [concat] step"); def_flatten_body = text_to_expression("<{} [concat] step");
def_fork_body = text_to_expression("[i] app2"); def_fork_body = text_to_expression("[i] app2");
def_fourth_body = text_to_expression("rest third"); def_fourth_body = text_to_expression("rest third");
@ -202,7 +211,6 @@ init_defs(void)
def_genrec_body = text_to_expression("[[genrec] ccccons] nullary swons concat ifte"); def_genrec_body = text_to_expression("[[genrec] ccccons] nullary swons concat ifte");
def_grabN_body = text_to_expression("<{} [cons] times"); def_grabN_body = text_to_expression("<{} [cons] times");
def_grba_body = text_to_expression("[stack popd] dip"); def_grba_body = text_to_expression("[stack popd] dip");
def_hypot_body = text_to_expression("[sqr] ii + sqrt");
def_ifte_body = text_to_expression("[nullary] dipd swap branch"); def_ifte_body = text_to_expression("[nullary] dipd swap branch");
def_ii_body = text_to_expression("[dip] dupdip i"); def_ii_body = text_to_expression("[dip] dupdip i");
def_infra_body = text_to_expression("swons swaack [i] dip swaack"); def_infra_body = text_to_expression("swons swaack [i] dip swaack");
@ -213,7 +221,7 @@ init_defs(void)
def_not_body = text_to_expression("[true] [false] branch"); def_not_body = text_to_expression("[true] [false] branch");
def_nulco_body = text_to_expression("[nullary] cons"); def_nulco_body = text_to_expression("[nullary] cons");
def_nullary_body = text_to_expression("[stack] dinfrirst"); def_nullary_body = text_to_expression("[stack] dinfrirst");
def_null_body = text_to_expression("[] swap concat bool not"); def_null_body = text_to_expression("_isnt_list bool not");
def_of_body = text_to_expression("swap at"); def_of_body = text_to_expression("swap at");
def_or_body = text_to_expression("nulco [nullary] dip [true] branch"); def_or_body = text_to_expression("nulco [nullary] dip [true] branch");
def_over_body = text_to_expression("[dup] dip swap"); def_over_body = text_to_expression("[dup] dip swap");
@ -282,12 +290,16 @@ init_defs(void)
def__map0_body = text_to_expression("[_map1] dipd _map2"); def__map0_body = text_to_expression("[_map1] dipd _map2");
def__map1_body = text_to_expression("stackd shift"); def__map1_body = text_to_expression("stackd shift");
def__map2_body = text_to_expression("[infrst] cons dipd roll< swons"); def__map2_body = text_to_expression("[infrst] cons dipd roll< swons");
def__isnt_bool_body = text_to_expression("not not"); def__isnt_bool_body = text_to_expression("[false] [true] branch");
def__isnt_two_bools_body = text_to_expression("[_isnt_bool] ii"); def__isnt_two_bools_body = text_to_expression("[_isnt_bool] ii");
def___REVERSE_SOLIDUS_SOLIDUS___body = text_to_expression("[_isnt_bool] [not] branch"); def___REVERSE_SOLIDUS_SOLIDUS___body = text_to_expression("[_isnt_bool] [not] branch");
def_SOLIDUS_REVERSE_SOLIDUS_body = text_to_expression("_isnt_two_bools [pop false] [] branch"); def_SOLIDUS_REVERSE_SOLIDUS_body = text_to_expression("_isnt_two_bools [pop false] [] branch");
def_REVERSE_SOLIDUS_SOLIDUS_body = text_to_expression("_isnt_two_bools [] [pop true] branch"); def_REVERSE_SOLIDUS_SOLIDUS_body = text_to_expression("_isnt_two_bools [] [pop true] branch");
def_xor_body = text_to_expression("[] [not] branch"); def__isnt_list_body = text_to_expression("[] swoncat");
def_zip_body = text_to_expression("[null] [pop] [shift-pair] [i cons] genrec");
def_shift_HYPHEN_MINUS_pair_body = text_to_expression("uncons-two [quote-two] dipd");
def_uncons_HYPHEN_MINUS_two_body = text_to_expression("[uncons] ii swapd");
def_quote_HYPHEN_MINUS_two_body = text_to_expression("unit cons");
} }
@ -326,6 +338,8 @@ void def_codi(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) {
void def_codireco(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_codireco_body, expression); } void def_codireco(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_codireco_body, expression); }
void def_dinfrirst(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dinfrirst_body, expression); } void def_dinfrirst(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dinfrirst_body, expression); }
void def_dipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dipd_body, expression); } void def_dipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dipd_body, expression); }
void def_dipdd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dipdd_body, expression); }
void def_dipddd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dipddd_body, expression); }
void def_disenstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_disenstacken_body, expression); } void def_disenstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_disenstacken_body, expression); }
void def_divmod(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_divmod_body, expression); } void def_divmod(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_divmod_body, expression); }
void def_down_to_zero(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_down_to_zero_body, expression); } void def_down_to_zero(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_down_to_zero_body, expression); }
@ -335,6 +349,7 @@ void def_dupd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) {
void def_dupdipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdipd_body, expression); } void def_dupdipd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdipd_body, expression); }
void def_dupdip(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdip_body, expression); } void def_dupdip(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_dupdip_body, expression); }
void def_enstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_enstacken_body, expression); } void def_enstacken(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_enstacken_body, expression); }
void def_first_two(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_first_two_body, expression); }
void def_flatten(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_flatten_body, expression); } void def_flatten(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_flatten_body, expression); }
void def_fork(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fork_body, expression); } void def_fork(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fork_body, expression); }
void def_fourth(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fourth_body, expression); } void def_fourth(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_fourth_body, expression); }
@ -342,7 +357,6 @@ void def_gcd(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) {
void def_genrec(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_genrec_body, expression); } void def_genrec(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_genrec_body, expression); }
void def_grabN(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grabN_body, expression); } void def_grabN(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grabN_body, expression); }
void def_grba(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grba_body, expression); } void def_grba(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_grba_body, expression); }
void def_hypot(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_hypot_body, expression); }
void def_ifte(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ifte_body, expression); } void def_ifte(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ifte_body, expression); }
void def_ii(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ii_body, expression); } void def_ii(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_ii_body, expression); }
void def_infra(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_infra_body, expression); } void def_infra(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_infra_body, expression); }
@ -427,4 +441,8 @@ void def__isnt_two_bools(__attribute__((unused)) JoyListPtr stack, JoyListPtr ex
void def___REVERSE_SOLIDUS_SOLIDUS__(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def___REVERSE_SOLIDUS_SOLIDUS___body, expression); } void def___REVERSE_SOLIDUS_SOLIDUS__(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def___REVERSE_SOLIDUS_SOLIDUS___body, expression); }
void def_SOLIDUS_REVERSE_SOLIDUS(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_SOLIDUS_REVERSE_SOLIDUS_body, expression); } void def_SOLIDUS_REVERSE_SOLIDUS(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_SOLIDUS_REVERSE_SOLIDUS_body, expression); }
void def_REVERSE_SOLIDUS_SOLIDUS(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_REVERSE_SOLIDUS_SOLIDUS_body, expression); } void def_REVERSE_SOLIDUS_SOLIDUS(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_REVERSE_SOLIDUS_SOLIDUS_body, expression); }
void def_xor(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_xor_body, expression); } void def__isnt_list(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def__isnt_list_body, expression); }
void def_zip(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_zip_body, expression); }
void def_shift_HYPHEN_MINUS_pair(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_shift_HYPHEN_MINUS_pair_body, expression); }
void def_uncons_HYPHEN_MINUS_two(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_uncons_HYPHEN_MINUS_two_body, expression); }
void def_quote_HYPHEN_MINUS_two(__attribute__((unused)) JoyListPtr stack, JoyListPtr expression) { push_quote_onto_expression(def_quote_HYPHEN_MINUS_two_body, expression); }

10
implementations/C/definitions.h
View File

@ -34,6 +34,8 @@ void def_codi(JoyListPtr stack, JoyListPtr expression);
void def_codireco(JoyListPtr stack, JoyListPtr expression); void def_codireco(JoyListPtr stack, JoyListPtr expression);
void def_dinfrirst(JoyListPtr stack, JoyListPtr expression); void def_dinfrirst(JoyListPtr stack, JoyListPtr expression);
void def_dipd(JoyListPtr stack, JoyListPtr expression); void def_dipd(JoyListPtr stack, JoyListPtr expression);
void def_dipdd(JoyListPtr stack, JoyListPtr expression);
void def_dipddd(JoyListPtr stack, JoyListPtr expression);
void def_disenstacken(JoyListPtr stack, JoyListPtr expression); void def_disenstacken(JoyListPtr stack, JoyListPtr expression);
void def_divmod(JoyListPtr stack, JoyListPtr expression); void def_divmod(JoyListPtr stack, JoyListPtr expression);
void def_down_to_zero(JoyListPtr stack, JoyListPtr expression); void def_down_to_zero(JoyListPtr stack, JoyListPtr expression);
@ -43,6 +45,7 @@ void def_dupd(JoyListPtr stack, JoyListPtr expression);
void def_dupdipd(JoyListPtr stack, JoyListPtr expression); void def_dupdipd(JoyListPtr stack, JoyListPtr expression);
void def_dupdip(JoyListPtr stack, JoyListPtr expression); void def_dupdip(JoyListPtr stack, JoyListPtr expression);
void def_enstacken(JoyListPtr stack, JoyListPtr expression); void def_enstacken(JoyListPtr stack, JoyListPtr expression);
void def_first_two(JoyListPtr stack, JoyListPtr expression);
void def_flatten(JoyListPtr stack, JoyListPtr expression); void def_flatten(JoyListPtr stack, JoyListPtr expression);
void def_fork(JoyListPtr stack, JoyListPtr expression); void def_fork(JoyListPtr stack, JoyListPtr expression);
void def_fourth(JoyListPtr stack, JoyListPtr expression); void def_fourth(JoyListPtr stack, JoyListPtr expression);
@ -50,7 +53,6 @@ void def_gcd(JoyListPtr stack, JoyListPtr expression);
void def_genrec(JoyListPtr stack, JoyListPtr expression); void def_genrec(JoyListPtr stack, JoyListPtr expression);
void def_grabN(JoyListPtr stack, JoyListPtr expression); void def_grabN(JoyListPtr stack, JoyListPtr expression);
void def_grba(JoyListPtr stack, JoyListPtr expression); void def_grba(JoyListPtr stack, JoyListPtr expression);
void def_hypot(JoyListPtr stack, JoyListPtr expression);
void def_ifte(JoyListPtr stack, JoyListPtr expression); void def_ifte(JoyListPtr stack, JoyListPtr expression);
void def_ii(JoyListPtr stack, JoyListPtr expression); void def_ii(JoyListPtr stack, JoyListPtr expression);
void def_infra(JoyListPtr stack, JoyListPtr expression); void def_infra(JoyListPtr stack, JoyListPtr expression);
@ -135,4 +137,8 @@ void def__isnt_two_bools(JoyListPtr stack, JoyListPtr expression);
void def___REVERSE_SOLIDUS_SOLIDUS__(JoyListPtr stack, JoyListPtr expression); void def___REVERSE_SOLIDUS_SOLIDUS__(JoyListPtr stack, JoyListPtr expression);
void def_SOLIDUS_REVERSE_SOLIDUS(JoyListPtr stack, JoyListPtr expression); void def_SOLIDUS_REVERSE_SOLIDUS(JoyListPtr stack, JoyListPtr expression);
void def_REVERSE_SOLIDUS_SOLIDUS(JoyListPtr stack, JoyListPtr expression); void def_REVERSE_SOLIDUS_SOLIDUS(JoyListPtr stack, JoyListPtr expression);
void def_xor(JoyListPtr stack, JoyListPtr expression); void def__isnt_list(JoyListPtr stack, JoyListPtr expression);
void def_zip(JoyListPtr stack, JoyListPtr expression);
void def_shift_HYPHEN_MINUS_pair(JoyListPtr stack, JoyListPtr expression);
void def_uncons_HYPHEN_MINUS_two(JoyListPtr stack, JoyListPtr expression);
void def_quote_HYPHEN_MINUS_two(JoyListPtr stack, JoyListPtr expression);

14
implementations/C/defs.txt
View File

@ -31,6 +31,8 @@ codi cons dip
codireco codi reco codireco codi reco
dinfrirst dip infrst dinfrirst dip infrst
dipd [dip] codi dipd [dip] codi
dipdd [dip] cons dipd
dipddd [dipd] cons dipd
disenstacken swaack pop disenstacken swaack pop
divmod [/] [%] clop divmod [/] [%] clop
down_to_zero [0 >] [dup --] while down_to_zero [0 >] [dup --] while
@ -41,6 +43,7 @@ dupdipd dup dipd
dupdip dupd dip dupdip dupd dip
enstacken stack [clear] dip enstacken stack [clear] dip
first uncons pop first uncons pop
first_two uncons first
flatten <{} [concat] step flatten <{} [concat] step
fork [i] app2 fork [i] app2
fourth rest third fourth rest third
@ -48,7 +51,6 @@ gcd true [tuck mod dup 0 >] loop pop
genrec [[genrec] ccccons] nullary swons concat ifte genrec [[genrec] ccccons] nullary swons concat ifte
grabN <{} [cons] times grabN <{} [cons] times
grba [stack popd] dip grba [stack popd] dip
hypot [sqr] ii + sqrt
ifte [nullary] dipd swap branch ifte [nullary] dipd swap branch
ii [dip] dupdip i ii [dip] dupdip i
infra swons swaack [i] dip swaack infra swons swaack [i] dip swaack
@ -61,7 +63,7 @@ neg 0 swap -
not [true] [false] branch not [true] [false] branch
nulco [nullary] cons nulco [nullary] cons
nullary [stack] dinfrirst nullary [stack] dinfrirst
null [] swap concat bool not null _isnt_list bool not
of swap at of swap at
or nulco [nullary] dip [true] branch or nulco [nullary] dip [true] branch
over [dup] dip swap over [dup] dip swap
@ -132,9 +134,13 @@ _mape popd reverse
_map0 [_map1] dipd _map2 _map0 [_map1] dipd _map2
_map1 stackd shift _map1 stackd shift
_map2 [infrst] cons dipd roll< swons _map2 [infrst] cons dipd roll< swons
_isnt_bool not not _isnt_bool [false] [true] branch
_isnt_two_bools [_isnt_bool] ii _isnt_two_bools [_isnt_bool] ii
_\/_ [_isnt_bool] [not] branch _\/_ [_isnt_bool] [not] branch
/\ _isnt_two_bools [pop false] [] branch /\ _isnt_two_bools [pop false] [] branch
\/ _isnt_two_bools [] [pop true] branch \/ _isnt_two_bools [] [pop true] branch
xor [] [not] branch _isnt_list [] swoncat
zip [null] [pop] [shift-pair] [i cons] genrec
shift-pair uncons-two [quote-two] dipd
uncons-two [uncons] ii swapd
quote-two unit cons

761
implementations/C/keywords.c
View File

@ -36,7 +36,7 @@
#line 13 "KEYWORDS.txt" #line 13 "KEYWORDS.txt"
struct dict_entry; struct dict_entry;
#include <string.h> #include <string.h>
/* maximum key range = 359, duplicates = 0 */ /* maximum key range = 323, duplicates = 0 */
#ifdef __GNUC__ #ifdef __GNUC__
__inline __inline
@ -50,32 +50,32 @@ keyword_hash (register const char *str, register size_t len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 35, 360, 360, 360, 60, 360, 360, 324, 324, 324, 110, 324, 324, 324, 105, 324, 324,
360, 360, 30, 85, 360, 45, 360, 20, 60, 35, 324, 324, 100, 50, 324, 35, 324, 10, 35, 10,
0, 25, 360, 360, 360, 360, 360, 360, 360, 360, 80, 35, 324, 324, 324, 324, 324, 324, 324, 324,
10, 90, 0, 80, 360, 360, 360, 360, 360, 360, 95, 60, 15, 40, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 20, 360, 324, 324, 324, 324, 324, 324, 324, 324, 40, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 30, 360, 360, 90, 360, 100, 70, 0, 324, 324, 15, 324, 324, 100, 324, 20, 70, 15,
5, 30, 40, 115, 15, 15, 360, 50, 40, 60, 5, 60, 55, 100, 55, 0, 324, 55, 35, 100,
0, 15, 0, 85, 70, 30, 25, 0, 95, 30, 0, 0, 0, 110, 65, 0, 30, 15, 80, 160,
25, 10, 20, 40, 360, 0, 360, 360, 360, 360, 55, 85, 15, 5, 324, 0, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360, 360, 360, 360, 360, 324, 324, 324, 324, 324, 324, 324, 324, 324, 324,
360, 360, 360, 360, 360, 360 324, 324, 324, 324, 324, 324
}; };
register unsigned int hval = len; register unsigned int hval = len;
@ -99,424 +99,433 @@ in_word_set (register const char *str, register size_t len)
{ {
enum enum
{ {
TOTAL_KEYWORDS = 170, TOTAL_KEYWORDS = 176,
MIN_WORD_LENGTH = 1, MIN_WORD_LENGTH = 1,
MAX_WORD_LENGTH = 15, MAX_WORD_LENGTH = 15,
MIN_HASH_VALUE = 1, MIN_HASH_VALUE = 1,
MAX_HASH_VALUE = 359 MAX_HASH_VALUE = 323
}; };
static const struct dict_entry wordlist[] = static const struct dict_entry wordlist[] =
{ {
{""}, {""},
#line 16 "KEYWORDS.txt" #line 43 "KEYWORDS.txt"
{">", def_gt}, {"i", i_joyfunc},
#line 134 "KEYWORDS.txt" #line 103 "KEYWORDS.txt"
{">>", def_GREATER_THAN_SIGN_GREATER_THAN_SIGN}, {"ii", def_ii},
{""}, {""}, {""}, {""}, {""},
#line 41 "KEYWORDS.txt"
{"dup", dup},
{""}, {""},
#line 90 "KEYWORDS.txt"
{"dupdip", def_dupdip},
#line 19 "KEYWORDS.txt"
{"<>", def_neq},
{""},
#line 88 "KEYWORDS.txt"
{"dupd", def_dupd},
#line 87 "KEYWORDS.txt"
{"dupdd", def_dupdd},
{""},
#line 89 "KEYWORDS.txt"
{"dupdipd", def_dupdipd},
#line 46 "KEYWORDS.txt" #line 46 "KEYWORDS.txt"
{"pop", pop}, {"pop", pop},
{""}, {""},
#line 121 "KEYWORDS.txt" #line 123 "KEYWORDS.txt"
{"popop", def_popop}, {"popop", def_popop},
#line 17 "KEYWORDS.txt" {""},
{"<", def_lt}, #line 122 "KEYWORDS.txt"
#line 120 "KEYWORDS.txt"
{"popopop", def_popopop}, {"popopop", def_popopop},
#line 40 "KEYWORDS.txt" #line 40 "KEYWORDS.txt"
{"dip", dip}, {"dip", dip},
#line 117 "KEYWORDS.txt"
{"popd", def_popd},
#line 116 "KEYWORDS.txt"
{"popdd", def_popdd},
#line 119 "KEYWORDS.txt" #line 119 "KEYWORDS.txt"
{"popopd", def_popopd}, {"popd", def_popd},
#line 118 "KEYWORDS.txt" #line 118 "KEYWORDS.txt"
{"popdd", def_popdd},
#line 121 "KEYWORDS.txt"
{"popopd", def_popopd},
#line 120 "KEYWORDS.txt"
{"popopdd", def_popopdd}, {"popopdd", def_popopdd},
{""}, {""},
#line 82 "KEYWORDS.txt" #line 82 "KEYWORDS.txt"
{"dipd", def_dipd}, {"dipd", def_dipd},
{""}, #line 83 "KEYWORDS.txt"
#line 43 "KEYWORDS.txt" {"dipdd", def_dipdd},
{"i", i_joyfunc}, #line 84 "KEYWORDS.txt"
#line 104 "KEYWORDS.txt" {"dipddd", def_dipddd},
{"<<", def_LESS_THAN_SIGN_LESS_THAN_SIGN}, #line 85 "KEYWORDS.txt"
{""}, {""}, {""}, {"disenstacken", def_disenstacken},
#line 158 "KEYWORDS.txt" #line 187 "KEYWORDS.txt"
{"uncons", def_uncons}, {"zip", def_zip},
#line 75 "KEYWORDS.txt" #line 38 "KEYWORDS.txt"
{"ccccons", def_ccccons}, {"cons", cons},
{""},
#line 79 "KEYWORDS.txt"
{"codi", def_codi},
{""}, {""},
#line 30 "KEYWORDS.txt" #line 30 "KEYWORDS.txt"
{"/", fdiv_q}, {"/", fdiv_q},
#line 51 "KEYWORDS.txt" #line 164 "KEYWORDS.txt"
{"fn", fn}, {"unswons", def_unswons},
#line 41 "KEYWORDS.txt"
{"dup", dup},
#line 79 "KEYWORDS.txt"
{"codi", def_codi},
{""},
#line 92 "KEYWORDS.txt"
{"dupdip", def_dupdip},
{""},
#line 80 "KEYWORDS.txt" #line 80 "KEYWORDS.txt"
{"codireco", def_codireco}, {"codireco", def_codireco},
#line 159 "KEYWORDS.txt" #line 90 "KEYWORDS.txt"
{"dupd", def_dupd},
#line 89 "KEYWORDS.txt"
{"dupdd", def_dupdd},
#line 16 "KEYWORDS.txt"
{">", def_gt},
#line 91 "KEYWORDS.txt"
{"dupdipd", def_dupdipd},
#line 66 "KEYWORDS.txt"
{"and", def_and},
#line 67 "KEYWORDS.txt"
{"app1", def_app1},
#line 76 "KEYWORDS.txt"
{"ccons", def_ccons},
#line 160 "KEYWORDS.txt"
{"uncons", def_uncons},
#line 185 "KEYWORDS.txt"
{"\\/", def_REVERSE_SOLIDUS_SOLIDUS},
#line 27 "KEYWORDS.txt"
{"add", add},
#line 45 "KEYWORDS.txt"
{"loop", loop},
#line 189 "KEYWORDS.txt"
{"uncons-two", def_uncons_HYPHEN_MINUS_two},
#line 143 "KEYWORDS.txt"
{"spiral_next", def_spiral_next},
#line 184 "KEYWORDS.txt"
{"/\\", def_SOLIDUS_REVERSE_SOLIDUS},
{""},
#line 81 "KEYWORDS.txt"
{"dinfrirst", def_dinfrirst},
{""}, {""},
#line 136 "KEYWORDS.txt"
{">>", def_GREATER_THAN_SIGN_GREATER_THAN_SIGN},
{""},
#line 161 "KEYWORDS.txt"
{"unit", def_unit}, {"unit", def_unit},
{""}, {""},
#line 39 "KEYWORDS.txt" #line 39 "KEYWORDS.txt"
{"concat", concat}, {"concat", concat},
#line 101 "KEYWORDS.txt" #line 75 "KEYWORDS.txt"
{"ii", def_ii}, {"ccccons", def_ccccons},
{""}, #line 149 "KEYWORDS.txt"
#line 38 "KEYWORDS.txt" {"stuncons", def_stuncons},
{"cons", cons},
#line 76 "KEYWORDS.txt"
{"ccons", def_ccons},
#line 164 "KEYWORDS.txt"
{"x", def_x},
{""},
#line 62 "KEYWORDS.txt"
{"<{}", def_LESS_THAN_SIGN_LEFT_CURLY_BRACKET_RIGHT_CURLY_BRACKET},
#line 81 "KEYWORDS.txt"
{"dinfrirst", def_dinfrirst},
#line 99 "KEYWORDS.txt"
{"hypot", def_hypot},
{""},
#line 109 "KEYWORDS.txt"
{"nullary", def_nullary},
{""},
#line 78 "KEYWORDS.txt" #line 78 "KEYWORDS.txt"
{"clop", def_clop}, {"clop", def_clop},
#line 108 "KEYWORDS.txt"
{"nulco", def_nulco},
#line 24 "KEYWORDS.txt"
{"*", mul},
#line 83 "KEYWORDS.txt"
{"disenstacken", def_disenstacken},
#line 37 "KEYWORDS.txt"
{"cmp", cmp_joyfunc},
#line 63 "KEYWORDS.txt"
{"<<{}", def_LESS_THAN_SIGN_LESS_THAN_SIGN_LEFT_CURLY_BRACKET_RIGHT_CURLY_BRACKET},
#line 155 "KEYWORDS.txt"
{"third", def_third},
{""},
#line 162 "KEYWORDS.txt"
{"unswons", def_unswons},
#line 107 "KEYWORDS.txt"
{"not", def_not},
#line 91 "KEYWORDS.txt"
{"enstacken", def_enstacken},
{""},
#line 136 "KEYWORDS.txt"
{"second", def_second},
#line 183 "KEYWORDS.txt"
{"\\/", def_REVERSE_SOLIDUS_SOLIDUS},
#line 135 "KEYWORDS.txt"
{"run", def_run},
#line 45 "KEYWORDS.txt"
{"loop", loop},
#line 138 "KEYWORDS.txt"
{"shunt", def_shunt},
#line 94 "KEYWORDS.txt"
{"fourth", def_fourth},
#line 85 "KEYWORDS.txt"
{"down_to_zero", def_down_to_zero},
#line 122 "KEYWORDS.txt"
{"pow", def_pow},
#line 156 "KEYWORDS.txt"
{"tuck", def_tuck},
{""},
#line 141 "KEYWORDS.txt"
{"spiral_next", def_spiral_next},
#line 182 "KEYWORDS.txt"
{"/\\", def_SOLIDUS_REVERSE_SOLIDUS},
#line 44 "KEYWORDS.txt"
{"inscribe", inscribe},
#line 110 "KEYWORDS.txt" #line 110 "KEYWORDS.txt"
{"null", def_null}, {"nulco", def_nulco},
{""}, {""},
#line 103 "KEYWORDS.txt" #line 51 "KEYWORDS.txt"
{"infrst", def_infrst}, {"fn", fn},
#line 161 "KEYWORDS.txt"
{"unstack", def_unstack},
#line 23 "KEYWORDS.txt"
{"mod", fdiv_r},
#line 165 "KEYWORDS.txt"
{"step", def_step},
#line 137 "KEYWORDS.txt"
{"shift", def_shift},
#line 28 "KEYWORDS.txt"
{"-", sub},
#line 54 "KEYWORDS.txt"
{"lt", def_lt},
#line 147 "KEYWORDS.txt"
{"stuncons", def_stuncons},
#line 86 "KEYWORDS.txt"
{"drop", def_drop},
#line 163 "KEYWORDS.txt"
{"while", def_while},
{""}, {""},
#line 111 "KEYWORDS.txt"
{"of", def_of},
#line 160 "KEYWORDS.txt"
{"unquoted", def_unquoted},
#line 139 "KEYWORDS.txt"
{"size", def_size},
{""},
#line 74 "KEYWORDS.txt"
{"binary", def_binary},
#line 56 "KEYWORDS.txt"
{"le", def_le},
#line 142 "KEYWORDS.txt"
{"split_at", def_split_at},
#line 68 "KEYWORDS.txt"
{"app2", def_app2},
#line 143 "KEYWORDS.txt"
{"split_list", def_split_list},
#line 77 "KEYWORDS.txt"
{"cleave", def_cleave},
#line 150 "KEYWORDS.txt"
{"swoncat", def_swoncat},
{""},
#line 146 "KEYWORDS.txt"
{"step_zero", def_step_zero},
#line 151 "KEYWORDS.txt"
{"swons", def_swons},
#line 124 "KEYWORDS.txt"
{"quoted", def_quoted},
{""},
#line 66 "KEYWORDS.txt"
{"and", def_and},
#line 100 "KEYWORDS.txt"
{"ifte", def_ifte},
#line 157 "KEYWORDS.txt"
{"unary", def_unary},
#line 32 "KEYWORDS.txt"
{"lshift", lshift},
#line 123 "KEYWORDS.txt"
{"product", def_product},
#line 27 "KEYWORDS.txt"
{"add", add},
#line 127 "KEYWORDS.txt"
{"reco", def_reco},
{""},
#line 22 "KEYWORDS.txt"
{"%", fdiv_r},
#line 115 "KEYWORDS.txt"
{"pm", def_pm},
{""},
#line 70 "KEYWORDS.txt"
{"appN", def_appN},
{""},
#line 84 "KEYWORDS.txt"
{"divmod", def_divmod},
#line 59 "KEYWORDS.txt"
{"!-", def_EXCLAMATION_MARK_HYPHEN_MINUS},
#line 95 "KEYWORDS.txt"
{"gcd", def_gcd},
#line 69 "KEYWORDS.txt" #line 69 "KEYWORDS.txt"
{"app3", def_app3}, {"app3", def_app3},
#line 131 "KEYWORDS.txt"
{"roll>", def_roll_GREATER_THAN_SIGN},
#line 132 "KEYWORDS.txt"
{"rollup", def_rollup},
{""}, {""},
#line 129 "KEYWORDS.txt" #line 147 "KEYWORDS.txt"
{"rolldown", def_rolldown}, {"stackd", def_stackd},
{""}, {""},
#line 169 "KEYWORDS.txt" #line 109 "KEYWORDS.txt"
{"times", def_times}, {"not", def_not},
{""}, #line 70 "KEYWORDS.txt"
#line 61 "KEYWORDS.txt" {"appN", def_appN},
{"--", def_HYPHEN_MINUS_HYPHEN_MINUS},
{""},
#line 67 "KEYWORDS.txt"
{"app1", def_app1},
#line 130 "KEYWORDS.txt"
{"roll<", def_roll_LESS_THAN_SIGN},
#line 73 "KEYWORDS.txt"
{"b", def_b},
#line 154 "KEYWORDS.txt"
{"ternary", def_ternary},
#line 25 "KEYWORDS.txt"
{"mul", mul},
#line 34 "KEYWORDS.txt"
{"bool", truthy},
#line 36 "KEYWORDS.txt"
{"clear", clear},
#line 33 "KEYWORDS.txt"
{"rshift", rshift},
#line 152 "KEYWORDS.txt"
{"tailrec", def_tailrec},
{""}, {""}, {""}, {""}, {""}, {""},
#line 96 "KEYWORDS.txt" #line 44 "KEYWORDS.txt"
{"genrec", def_genrec}, {"inscribe", inscribe},
#line 71 "KEYWORDS.txt" #line 93 "KEYWORDS.txt"
{"at", def_at}, {"enstacken", def_enstacken},
#line 148 "KEYWORDS.txt"
{"sum", def_sum},
{""}, {""},
#line 42 "KEYWORDS.txt" #line 28 "KEYWORDS.txt"
{"first", first}, {"-", sub},
#line 154 "KEYWORDS.txt"
{"tailrec", def_tailrec},
#line 144 "KEYWORDS.txt"
{"split_at", def_split_at},
#line 88 "KEYWORDS.txt"
{"drop", def_drop},
#line 145 "KEYWORDS.txt"
{"split_list", def_split_list},
{""}, {""},
#line 112 "KEYWORDS.txt" #line 163 "KEYWORDS.txt"
{"or", def_or}, {"unstack", def_unstack},
{""}, {""},
#line 47 "KEYWORDS.txt" #line 141 "KEYWORDS.txt"
{"rest", rest}, {"size", def_size},
#line 102 "KEYWORDS.txt" #line 104 "KEYWORDS.txt"
{"infra", def_infra}, {"infra", def_infra},
#line 58 "KEYWORDS.txt" #line 58 "KEYWORDS.txt"
{"?", def_QUESTION_MARK}, {"?", def_QUESTION_MARK},
#line 172 "KEYWORDS.txt" #line 71 "KEYWORDS.txt"
{"_timest", def__timest}, {"at", def_at},
#line 173 "KEYWORDS.txt" #line 137 "KEYWORDS.txt"
{"map", def_map}, {"run", def_run},
#line 50 "KEYWORDS.txt" {""}, {""},
{"swap", swap}, #line 138 "KEYWORDS.txt"
{"second", def_second},
{""}, {""},
#line 112 "KEYWORDS.txt"
{"null", def_null},
#line 139 "KEYWORDS.txt"
{"shift", def_shift},
#line 105 "KEYWORDS.txt"
{"infrst", def_infrst},
{""}, {""},
#line 145 "KEYWORDS.txt" #line 64 "KEYWORDS.txt"
{"stackd", def_stackd}, {"abs", def_abs},
#line 167 "KEYWORDS.txt"
{"step", def_step},
#line 157 "KEYWORDS.txt"
{"third", def_third},
#line 86 "KEYWORDS.txt"
{"divmod", def_divmod},
#line 54 "KEYWORDS.txt"
{"lt", def_lt},
#line 128 "KEYWORDS.txt"
{"range_to_zero", def_range_to_zero},
#line 148 "KEYWORDS.txt"
{"step_zero", def_step_zero},
{""},
#line 26 "KEYWORDS.txt"
{"+", add},
#line 125 "KEYWORDS.txt"
{"product", def_product},
#line 62 "KEYWORDS.txt"
{"<{}", def_LESS_THAN_SIGN_LEFT_CURLY_BRACKET_RIGHT_CURLY_BRACKET},
#line 68 "KEYWORDS.txt"
{"app2", def_app2},
#line 140 "KEYWORDS.txt"
{"shunt", def_shunt},
#line 134 "KEYWORDS.txt"
{"rollup", def_rollup},
#line 61 "KEYWORDS.txt"
{"--", def_HYPHEN_MINUS_HYPHEN_MINUS},
#line 131 "KEYWORDS.txt"
{"rolldown", def_rolldown},
#line 34 "KEYWORDS.txt"
{"bool", truthy},
#line 48 "KEYWORDS.txt"
{"stack", stack},
#line 166 "KEYWORDS.txt"
{"x", def_x},
#line 113 "KEYWORDS.txt"
{"of", def_of},
#line 23 "KEYWORDS.txt"
{"mod", fdiv_r},
{""},
#line 182 "KEYWORDS.txt"
{"_isnt_two_bools", def__isnt_two_bools},
{""},
#line 95 "KEYWORDS.txt"
{"flatten", def_flatten},
#line 37 "KEYWORDS.txt"
{"cmp", cmp_joyfunc},
#line 158 "KEYWORDS.txt"
{"tuck", def_tuck},
#line 133 "KEYWORDS.txt"
{"roll>", def_roll_GREATER_THAN_SIGN},
#line 15 "KEYWORDS.txt"
{"=", def_eq},
{""},
#line 175 "KEYWORDS.txt"
{"map", def_map},
{""},
#line 159 "KEYWORDS.txt"
{"unary", def_unary},
#line 32 "KEYWORDS.txt"
{"lshift", lshift},
#line 19 "KEYWORDS.txt"
{"<>", def_neq},
#line 98 "KEYWORDS.txt"
{"gcd", def_gcd},
#line 94 "KEYWORDS.txt"
{"first_two", def_first_two},
#line 188 "KEYWORDS.txt"
{"shift-pair", def_shift_HYPHEN_MINUS_pair},
#line 97 "KEYWORDS.txt"
{"fourth", def_fourth},
#line 114 "KEYWORDS.txt"
{"or", def_or},
{""},
#line 190 "KEYWORDS.txt"
{"quote-two", def_quote_HYPHEN_MINUS_two},
#line 171 "KEYWORDS.txt"
{"times", def_times},
#line 126 "KEYWORDS.txt"
{"quoted", def_quoted},
#line 21 "KEYWORDS.txt"
{">=", def_ge},
#line 162 "KEYWORDS.txt"
{"unquoted", def_unquoted},
{""},
#line 186 "KEYWORDS.txt"
{"_isnt_list", def__isnt_list},
#line 73 "KEYWORDS.txt"
{"b", def_b},
#line 111 "KEYWORDS.txt"
{"nullary", def_nullary},
{""},
#line 129 "KEYWORDS.txt"
{"reco", def_reco},
#line 181 "KEYWORDS.txt"
{"_isnt_bool", def__isnt_bool},
#line 169 "KEYWORDS.txt"
{"_step1", def__step1},
#line 173 "KEYWORDS.txt"
{"_times1", def__times1},
{""},
#line 102 "KEYWORDS.txt"
{"ifte", def_ifte},
#line 127 "KEYWORDS.txt"
{"range", def_range},
#line 65 "KEYWORDS.txt"
{"anamorphism", def_anamorphism},
#line 60 "KEYWORDS.txt"
{"++", def_PLUS_SIGN_PLUS_SIGN},
{""}, {""},
#line 42 "KEYWORDS.txt"
{"first", first},
#line 33 "KEYWORDS.txt"
{"rshift", rshift},
#line 56 "KEYWORDS.txt"
{"le", def_le},
#line 29 "KEYWORDS.txt"
{"sub", sub},
#line 47 "KEYWORDS.txt"
{"rest", rest},
#line 142 "KEYWORDS.txt"
{"small", def_small},
#line 74 "KEYWORDS.txt"
{"binary", def_binary},
#line 53 "KEYWORDS.txt" #line 53 "KEYWORDS.txt"
{"gt", def_gt}, {"gt", def_gt},
{""}, {""}, {""}, {""},
#line 149 "KEYWORDS.txt" #line 153 "KEYWORDS.txt"
{"swapd", def_swapd}, {"swons", def_swons},
#line 26 "KEYWORDS.txt" #line 170 "KEYWORDS.txt"
{"+", add},
#line 171 "KEYWORDS.txt"
{"_times1", def__times1},
#line 29 "KEYWORDS.txt"
{"sub", sub},
{""}, {""},
#line 168 "KEYWORDS.txt"
{"_stept", def__stept}, {"_stept", def__stept},
#line 57 "KEYWORDS.txt" #line 174 "KEYWORDS.txt"
{"ge", def_ge}, {"_timest", def__timest},
#line 31 "KEYWORDS.txt"
{"div", fdiv_q},
#line 155 "KEYWORDS.txt"
{"take", def_take},
{""}, {""},
#line 93 "KEYWORDS.txt" #line 168 "KEYWORDS.txt"
{"_step0", def__step0},
#line 172 "KEYWORDS.txt"
{"_times0", def__times0},
{""}, {""}, {""},
#line 77 "KEYWORDS.txt"
{"cleave", def_cleave},
#line 87 "KEYWORDS.txt"
{"down_to_zero", def_down_to_zero},
{""},
#line 96 "KEYWORDS.txt"
{"fork", def_fork}, {"fork", def_fork},
#line 180 "KEYWORDS.txt" #line 36 "KEYWORDS.txt"
{"_isnt_two_bools", def__isnt_two_bools}, {"clear", clear},
#line 15 "KEYWORDS.txt" #line 99 "KEYWORDS.txt"
{"=", def_eq}, {"genrec", def_genrec},
#line 21 "KEYWORDS.txt" #line 59 "KEYWORDS.txt"
{">=", def_ge}, {"!-", def_EXCLAMATION_MARK_HYPHEN_MINUS},
#line 184 "KEYWORDS.txt"
{"xor", def_xor},
{""}, {""},
#line 179 "KEYWORDS.txt" #line 50 "KEYWORDS.txt"
{"_isnt_bool", def__isnt_bool}, {"swap", swap},
#line 167 "KEYWORDS.txt" {""}, {""}, {""},
{"_step1", def__step1}, #line 25 "KEYWORDS.txt"
#line 92 "KEYWORDS.txt" {"mul", mul},
{"flatten", def_flatten}, {""},
#line 151 "KEYWORDS.txt"
{"swapd", def_swapd},
#line 17 "KEYWORDS.txt"
{"<", def_lt},
{""}, {""}, {""}, {""}, {""},
#line 152 "KEYWORDS.txt"
{"swoncat", def_swoncat},
{""},
#line 63 "KEYWORDS.txt"
{"<<{}", def_LESS_THAN_SIGN_LESS_THAN_SIGN_LEFT_CURLY_BRACKET_RIGHT_CURLY_BRACKET},
#line 132 "KEYWORDS.txt"
{"roll<", def_roll_LESS_THAN_SIGN},
#line 24 "KEYWORDS.txt"
{"*", mul},
#line 117 "KEYWORDS.txt"
{"pm", def_pm},
{""}, {""}, {""}, {""}, {""}, {""},
#line 115 "KEYWORDS.txt"
{"over", def_over},
{""},
#line 22 "KEYWORDS.txt"
{"%", fdiv_r},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 35 "KEYWORDS.txt"
{"branch", branch},
#line 20 "KEYWORDS.txt" #line 20 "KEYWORDS.txt"
{"<=", def_le}, {"<=", def_le},
{""}, {""}, {""}, {""}, #line 150 "KEYWORDS.txt"
#line 170 "KEYWORDS.txt" {"sum", def_sum},
{"_times0", def__times0}, {""}, {""}, {""},
#line 126 "KEYWORDS.txt" #line 57 "KEYWORDS.txt"
{"range_to_zero", def_range_to_zero}, {"ge", def_ge},
#line 116 "KEYWORDS.txt"
{"pam", def_pam},
{""}, {""},
#line 133 "KEYWORDS.txt" #line 135 "KEYWORDS.txt"
{"rrest", def_rrest}, {"rrest", def_rrest},
{""}, {""},
#line 72 "KEYWORDS.txt"
{"average", def_average},
{""},
#line 183 "KEYWORDS.txt"
{"_\\/_", def___REVERSE_SOLIDUS_SOLIDUS__},
#line 100 "KEYWORDS.txt"
{"grabN", def_grabN},
{""},
#line 18 "KEYWORDS.txt"
{"!=", def_neq},
{""}, {""},
#line 179 "KEYWORDS.txt"
{"_map1", def__map1},
{""}, {""}, {""}, {""}, {""},
#line 49 "KEYWORDS.txt"
{"swaack", swaack},
{""},
#line 146 "KEYWORDS.txt"
{"sqr", def_sqr},
{""}, {""}, {""},
#line 156 "KEYWORDS.txt"
{"ternary", def_ternary},
{""}, {""}, {""}, {""}, {""}, {""},
#line 107 "KEYWORDS.txt"
{"make_generator", def_make_generator},
{""}, {""}, {""}, {""},
#line 101 "KEYWORDS.txt"
{"grba", def_grba},
#line 178 "KEYWORDS.txt"
{"_map0", def__map0},
{""}, {""},
#line 108 "KEYWORDS.txt"
{"neg", def_neg},
{""},
#line 176 "KEYWORDS.txt"
{"_map?", def__map_QUESTION_MARK},
{""}, {""}, {""}, {""}, {""}, {""},
#line 130 "KEYWORDS.txt"
{"reverse", def_reverse},
{""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 165 "KEYWORDS.txt"
{"while", def_while},
{""},
#line 52 "KEYWORDS.txt" #line 52 "KEYWORDS.txt"
{"eq", def_eq}, {"eq", def_eq},
#line 55 "KEYWORDS.txt" #line 55 "KEYWORDS.txt"
{"neq", def_neq}, {"neq", def_neq},
{""}, {""},
#line 125 "KEYWORDS.txt"
{"range", def_range},
{""}, {""}, {""},
#line 153 "KEYWORDS.txt"
{"take", def_take},
#line 48 "KEYWORDS.txt"
{"stack", stack},
#line 166 "KEYWORDS.txt"
{"_step0", def__step0},
{""},
#line 31 "KEYWORDS.txt"
{"div", fdiv_q},
#line 113 "KEYWORDS.txt"
{"over", def_over},
{""},
#line 49 "KEYWORDS.txt"
{"swaack", swaack},
#line 18 "KEYWORDS.txt"
{"!=", def_neq},
{""}, {""}, {""}, {""}, {""},
#line 114 "KEYWORDS.txt"
{"pam", def_pam},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 128 "KEYWORDS.txt"
{"reverse", def_reverse},
#line 64 "KEYWORDS.txt"
{"abs", def_abs},
#line 181 "KEYWORDS.txt"
{"_\\/_", def___REVERSE_SOLIDUS_SOLIDUS__},
#line 140 "KEYWORDS.txt"
{"small", def_small},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""},
#line 178 "KEYWORDS.txt"
{"_map2", def__map2},
{""},
#line 60 "KEYWORDS.txt"
{"++", def_PLUS_SIGN_PLUS_SIGN},
#line 144 "KEYWORDS.txt"
{"sqr", def_sqr},
{""}, {""},
#line 35 "KEYWORDS.txt"
{"branch", branch},
#line 72 "KEYWORDS.txt"
{"average", def_average},
#line 106 "KEYWORDS.txt"
{"neg", def_neg},
{""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 65 "KEYWORDS.txt"
{"anamorphism", def_anamorphism},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""},
#line 175 "KEYWORDS.txt"
{"_mape", def__mape},
{""}, {""}, {""}, {""},
#line 177 "KEYWORDS.txt" #line 177 "KEYWORDS.txt"
{"_map1", def__map1}, {"_mape", def__mape},
{""}, {""}, {""},
#line 105 "KEYWORDS.txt"
{"make_generator", def_make_generator},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""}, {""},
#line 97 "KEYWORDS.txt"
{"grabN", def_grabN},
{""}, {""}, {""}, {""},
#line 176 "KEYWORDS.txt"
{"_map0", def__map0},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""},
#line 174 "KEYWORDS.txt" #line 106 "KEYWORDS.txt"
{"_map?", def__map_QUESTION_MARK}, {"<<", def_LESS_THAN_SIGN_LESS_THAN_SIGN},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 180 "KEYWORDS.txt"
{"_map2", def__map2},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
#line 98 "KEYWORDS.txt" #line 124 "KEYWORDS.txt"
{"grba", def_grba} {"pow", def_pow}
}; };
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

10
implementations/defs.txt
View File

@ -23,6 +23,7 @@ b [i] dip i
binary unary popd binary unary popd
ccccons ccons ccons ccccons ccons ccons
ccons cons cons ccons cons cons
choice [pop] [popd] branch
clear [] swaack pop clear [] swaack pop
cleave fork popdd cleave fork popdd
clop cleave popdd clop cleave popdd
@ -49,6 +50,7 @@ fork [i] app2
fourth rest third fourth rest third
gcd true [tuck mod dup 0 >] loop pop gcd true [tuck mod dup 0 >] loop pop
genrec [[genrec] ccccons] nullary swons concat ifte genrec [[genrec] ccccons] nullary swons concat ifte
getitem [rest] times first
grabN <{} [cons] times grabN <{} [cons] times
grba [stack popd] dip grba [stack popd] dip
ifte [nullary] dipd swap branch ifte [nullary] dipd swap branch
@ -59,6 +61,7 @@ infrst infra first
lshift [2 *] times lshift [2 *] times
make_generator [codireco] ccons make_generator [codireco] ccons
mod % mod %
modulus %
neg 0 swap - neg 0 swap -
not [true] [false] branch not [true] [false] branch
nulco [nullary] cons nulco [nullary] cons
@ -68,6 +71,7 @@ of swap at
or nulco [nullary] dip [true] branch or nulco [nullary] dip [true] branch
over [dup] dip swap over [dup] dip swap
pam [i] map pam [i] map
pick getitem
pm [+] [-] clop pm [+] [-] clop
popdd [pop] dipd popdd [pop] dipd
popd [pop] dip popd [pop] dip
@ -76,6 +80,7 @@ popopd [popop] dip
popopop pop popop popopop pop popop
popop pop pop popop pop pop
pow 1 roll> swap [*] cons times pow 1 roll> swap [*] cons times
pred --
product 1 swap [*] step product 1 swap [*] step
quoted [unit] dip quoted [unit] dip
range [0 <=] [-- dup] anamorphism range [0 <=] [-- dup] anamorphism
@ -103,6 +108,7 @@ sqr dup mul
stackd [stack] dip stackd [stack] dip
step_zero 0 roll> step step_zero 0 roll> step
stuncons stack uncons stuncons stack uncons
succ --
sum [+] step_zero sum [+] step_zero
swapd [swap] dip swapd [swap] dip
swoncat swap concat swoncat swap concat
@ -140,3 +146,7 @@ _\/_ [_isnt_bool] [not] branch
/\ _isnt_two_bools [pop false] [] branch /\ _isnt_two_bools [pop false] [] branch
\/ _isnt_two_bools [] [pop true] branch \/ _isnt_two_bools [] [pop true] branch
_isnt_list [] swoncat _isnt_list [] swoncat
zip [null] [pop] [uncons-pair] [i cons] genrec
uncons-pair uncons-two [quote-two] dipd
uncons-two [uncons] ii swapd
quote-two unit cons