Thread: [pure-lang-svn] SF.net SVN: pure-lang: [11] pure/trunk/test
Status: Beta
Brought to you by:
agraef
Menu
▾
▴
pure-lang-svn
|
From: <ag...@us...> - 2008-05-01 06:52:39
|
Revision: 11
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=11&view=rev
Author: agraef
Date: 2008-04-30 23:52:46 -0700 (Wed, 30 Apr 2008)
Log Message:
-----------
Added regressions reported by Tim Haynes.
Added Paths:
-----------
pure/trunk/test/test5.pure
pure/trunk/test/test6.pure
Added: pure/trunk/test/test5.pure
===================================================================
--- pure/trunk/test/test5.pure (rev 0)
+++ pure/trunk/test/test5.pure 2008-05-01 06:52:46 UTC (rev 11)
@@ -0,0 +1,4 @@
+fact 0 = 1;
+fact n = n * fact (n-1);
+fact 4;
+
Added: pure/trunk/test/test6.pure
===================================================================
--- pure/trunk/test/test6.pure (rev 0)
+++ pure/trunk/test/test6.pure 2008-05-01 06:52:46 UTC (rev 11)
@@ -0,0 +1,3 @@
+fact n = 1 if n==0;
+ = n * fact (n-1) otherwise;
+fact 4;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-05-02 20:30:42
|
Revision: 31
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=31&view=rev
Author: agraef
Date: 2008-05-02 13:30:47 -0700 (Fri, 02 May 2008)
Log Message:
-----------
Added test log files.
Added Paths:
-----------
pure/trunk/test/prelude.log
pure/trunk/test/test1.log
pure/trunk/test/test2.log
pure/trunk/test/test3.log
pure/trunk/test/test4.log
pure/trunk/test/test5.log
pure/trunk/test/test6.log
pure/trunk/test/test7.log
Added: pure/trunk/test/prelude.log
===================================================================
--- pure/trunk/test/prelude.log (rev 0)
+++ pure/trunk/test/prelude.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,650 @@
+throw x/*0:1*/ = pure_throw x/*0:1*/;
+x/*0:01*/===y/*0:1*/ = same x/*0:01*/ y/*0:1*/;
+x/*0:01*/!==y/*0:1*/ = not same x/*0:01*/ y/*0:1*/;
+intp x/*0:1*/ = case x/*0:1*/ of _/*0:*/::int = 1; _/*0:*/ = 0 {
+ rule #0: _::int = 1
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <var>::int state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+bigintp x/*0:1*/ = case x/*0:1*/ of _/*0:*/::bigint = 1; _/*0:*/ = 0 {
+ rule #0: _::bigint = 1
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <var>::bigint state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+doublep x/*0:1*/ = case x/*0:1*/ of _/*0:*/::double = 1; _/*0:*/ = 0 {
+ rule #0: _::double = 1
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <var>::double state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+stringp x/*0:1*/ = case x/*0:1*/ of _/*0:*/::string = 1; _/*0:*/ = 0 {
+ rule #0: _::string = 1
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <var>::string state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+pointerp x/*0:1*/ = case x/*0:1*/ of _/*0:*/ = 1; _/*0:*/ = 0 {
+ rule #0: _ = 1
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <var> state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+listp [] = 1;
+listp (x/*0:101*/:xs/*0:11*/) = listp xs/*0:11*/;
+listp _/*0:1*/ = 0;
+tuplep () = 1;
+tuplep (x/*0:101*/,xs/*0:11*/) = 1;
+tuplep _/*0:1*/ = 0;
+int x/*0:1*/::int = x/*0:1*/;
+int x/*0:1*/::bigint = pure_intval x/*0:1*/;
+int x/*0:1*/::double = pure_intval x/*0:1*/;
+int x/*0:1*/ = pure_intval x/*0:1*/;
+bigint x/*0:1*/::int = pure_bigintval x/*0:1*/;
+bigint x/*0:1*/::bigint = x/*0:1*/;
+bigint x/*0:1*/::double = pure_bigintval x/*0:1*/;
+bigint x/*0:1*/ = pure_bigintval x/*0:1*/;
+double x/*0:1*/::int = pure_dblval x/*0:1*/;
+double x/*0:1*/::bigint = pure_dblval x/*0:1*/;
+double x/*0:1*/::double = x/*0:1*/;
+pointer x/*0:1*/::int = pure_pointerval x/*0:1*/;
+pointer x/*0:1*/::bigint = pure_pointerval x/*0:1*/;
+pointer x/*0:1*/::double = pure_pointerval x/*0:1*/;
+pointer x/*0:1*/::string = pure_pointerval x/*0:1*/;
+pointer x/*0:1*/ = x/*0:1*/;
+-x/*0:1*/::int = -x/*0:1*/;
+~x/*0:1*/::int = ~x/*0:1*/;
+not x/*0:1*/::int = not x/*0:1*/;
+x/*0:01*/::int<<y/*0:1*/::int = x/*0:01*/<<y/*0:1*/;
+x/*0:01*/::int>>y/*0:1*/::int = x/*0:01*/>>y/*0:1*/;
+x/*0:01*/::int+y/*0:1*/::int = x/*0:01*/+y/*0:1*/;
+x/*0:01*/::int-y/*0:1*/::int = x/*0:01*/-y/*0:1*/;
+x/*0:01*/::int|y/*0:1*/::int = x/*0:01*/|y/*0:1*/;
+x/*0:01*/::int*y/*0:1*/::int = x/*0:01*/*y/*0:1*/;
+x/*0:01*/::int/y/*0:1*/::int = x/*0:01*//y/*0:1*/;
+x/*0:01*/::int&y/*0:1*/::int = x/*0:01*/&y/*0:1*/;
+x/*0:01*/::int div y/*0:1*/::int = x/*0:01*/ div y/*0:1*/;
+x/*0:01*/::int mod y/*0:1*/::int = x/*0:01*/ mod y/*0:1*/;
+x/*0:01*/::int<y/*0:1*/::int = x/*0:01*/<y/*0:1*/;
+x/*0:01*/::int>y/*0:1*/::int = x/*0:01*/>y/*0:1*/;
+x/*0:01*/::int<=y/*0:1*/::int = x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::int>=y/*0:1*/::int = x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::int==y/*0:1*/::int = x/*0:01*/==y/*0:1*/;
+x/*0:01*/::int!=y/*0:1*/::int = x/*0:01*/!=y/*0:1*/;
+-x/*0:1*/::double = -x/*0:1*/;
+x/*0:01*/::double+y/*0:1*/::double = x/*0:01*/+y/*0:1*/;
+x/*0:01*/::double-y/*0:1*/::double = x/*0:01*/-y/*0:1*/;
+x/*0:01*/::double*y/*0:1*/::double = x/*0:01*/*y/*0:1*/;
+x/*0:01*/::double/y/*0:1*/::double = x/*0:01*//y/*0:1*/;
+x/*0:01*/::double<y/*0:1*/::double = x/*0:01*/<y/*0:1*/;
+x/*0:01*/::double>y/*0:1*/::double = x/*0:01*/>y/*0:1*/;
+x/*0:01*/::double<=y/*0:1*/::double = x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::double>=y/*0:1*/::double = x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::double==y/*0:1*/::double = x/*0:01*/==y/*0:1*/;
+x/*0:01*/::double!=y/*0:1*/::double = x/*0:01*/!=y/*0:1*/;
+x/*0:01*/::int+y/*0:1*/::double = x/*0:01*/+y/*0:1*/;
+x/*0:01*/::int-y/*0:1*/::double = x/*0:01*/-y/*0:1*/;
+x/*0:01*/::int*y/*0:1*/::double = x/*0:01*/*y/*0:1*/;
+x/*0:01*/::int/y/*0:1*/::double = x/*0:01*//y/*0:1*/;
+x/*0:01*/::int<y/*0:1*/::double = x/*0:01*/<y/*0:1*/;
+x/*0:01*/::int>y/*0:1*/::double = x/*0:01*/>y/*0:1*/;
+x/*0:01*/::int<=y/*0:1*/::double = x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::int>=y/*0:1*/::double = x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::int==y/*0:1*/::double = x/*0:01*/==y/*0:1*/;
+x/*0:01*/::int!=y/*0:1*/::double = x/*0:01*/!=y/*0:1*/;
+x/*0:01*/::double+y/*0:1*/::int = x/*0:01*/+y/*0:1*/;
+x/*0:01*/::double-y/*0:1*/::int = x/*0:01*/-y/*0:1*/;
+x/*0:01*/::double*y/*0:1*/::int = x/*0:01*/*y/*0:1*/;
+x/*0:01*/::double/y/*0:1*/::int = x/*0:01*//y/*0:1*/;
+x/*0:01*/::double<y/*0:1*/::int = x/*0:01*/<y/*0:1*/;
+x/*0:01*/::double>y/*0:1*/::int = x/*0:01*/>y/*0:1*/;
+x/*0:01*/::double<=y/*0:1*/::int = x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::double>=y/*0:1*/::int = x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::double==y/*0:1*/::int = x/*0:01*/==y/*0:1*/;
+x/*0:01*/::double!=y/*0:1*/::int = x/*0:01*/!=y/*0:1*/;
+x/*0:01*/::int&&y/*0:1*/::int = x/*0:01*/&&y/*0:1*/;
+x/*0:01*/::int||y/*0:1*/::int = x/*0:01*/||y/*0:1*/;
+-x/*0:1*/::bigint = bigint_neg x/*0:1*/;
+~x/*0:1*/::bigint = bigint_not x/*0:1*/;
+not x/*0:1*/::bigint = not int x/*0:1*/;
+x/*0:01*/::bigint<<y/*0:1*/::int = bigint_shl x/*0:01*/ y/*0:1*/ if y/*0:1*/>=0;
+x/*0:01*/::bigint<<y/*0:1*/::int = bigint_shr x/*0:01*/ (-y/*0:1*/);
+x/*0:01*/::bigint>>y/*0:1*/::int = bigint_shr x/*0:01*/ y/*0:1*/ if y/*0:1*/>=0;
+x/*0:01*/::bigint>>y/*0:1*/::int = bigint_shl x/*0:01*/ (-y/*0:1*/);
+x/*0:01*/::bigint+y/*0:1*/::bigint = bigint_add x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint-y/*0:1*/::bigint = bigint_sub x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint|y/*0:1*/::bigint = bigint_or x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint*y/*0:1*/::bigint = bigint_mul x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint/y/*0:1*/::bigint = double x/*0:01*//double y/*0:1*/;
+x/*0:01*/::bigint&y/*0:1*/::bigint = bigint_and x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint div y/*0:1*/::bigint = bigint_div x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint mod y/*0:1*/::bigint = bigint_mod x/*0:01*/ y/*0:1*/;
+x/*0:01*/::bigint<y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/<0;
+x/*0:01*/::bigint>y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/>0;
+x/*0:01*/::bigint<=y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/<=0;
+x/*0:01*/::bigint>=y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/>=0;
+x/*0:01*/::bigint==y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/==0;
+x/*0:01*/::bigint!=y/*0:1*/::bigint = bigint_cmp x/*0:01*/ y/*0:1*/!=0;
+x/*0:01*/::int+y/*0:1*/::bigint = bigint x/*0:01*/+y/*0:1*/;
+x/*0:01*/::int-y/*0:1*/::bigint = bigint x/*0:01*/-y/*0:1*/;
+x/*0:01*/::int|y/*0:1*/::bigint = bigint x/*0:01*/|y/*0:1*/;
+x/*0:01*/::int*y/*0:1*/::bigint = bigint x/*0:01*/*y/*0:1*/;
+x/*0:01*/::int/y/*0:1*/::bigint = double x/*0:01*//y/*0:1*/;
+x/*0:01*/::int&y/*0:1*/::bigint = bigint x/*0:01*/&y/*0:1*/;
+x/*0:01*/::int div y/*0:1*/::bigint = bigint x/*0:01*/ div y/*0:1*/;
+x/*0:01*/::int mod y/*0:1*/::bigint = bigint x/*0:01*/ mod y/*0:1*/;
+x/*0:01*/::int<y/*0:1*/::bigint = bigint x/*0:01*/<y/*0:1*/;
+x/*0:01*/::int>y/*0:1*/::bigint = bigint x/*0:01*/>y/*0:1*/;
+x/*0:01*/::int<=y/*0:1*/::bigint = bigint x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::int>=y/*0:1*/::bigint = bigint x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::int==y/*0:1*/::bigint = bigint x/*0:01*/==y/*0:1*/;
+x/*0:01*/::int!=y/*0:1*/::bigint = bigint x/*0:01*/!=y/*0:1*/;
+x/*0:01*/::bigint+y/*0:1*/::int = x/*0:01*/+bigint y/*0:1*/;
+x/*0:01*/::bigint-y/*0:1*/::int = x/*0:01*/-bigint y/*0:1*/;
+x/*0:01*/::bigint|y/*0:1*/::int = x/*0:01*/|bigint y/*0:1*/;
+x/*0:01*/::bigint*y/*0:1*/::int = x/*0:01*/*bigint y/*0:1*/;
+x/*0:01*/::bigint/y/*0:1*/::int = x/*0:01*//double y/*0:1*/;
+x/*0:01*/::bigint&y/*0:1*/::int = x/*0:01*/&bigint y/*0:1*/;
+x/*0:01*/::bigint div y/*0:1*/::int = x/*0:01*/ div bigint y/*0:1*/;
+x/*0:01*/::bigint mod y/*0:1*/::int = x/*0:01*/ mod bigint y/*0:1*/;
+x/*0:01*/::bigint<y/*0:1*/::int = x/*0:01*/<bigint y/*0:1*/;
+x/*0:01*/::bigint>y/*0:1*/::int = x/*0:01*/>bigint y/*0:1*/;
+x/*0:01*/::bigint<=y/*0:1*/::int = x/*0:01*/<=bigint y/*0:1*/;
+x/*0:01*/::bigint>=y/*0:1*/::int = x/*0:01*/>=bigint y/*0:1*/;
+x/*0:01*/::bigint==y/*0:1*/::int = x/*0:01*/==bigint y/*0:1*/;
+x/*0:01*/::bigint!=y/*0:1*/::int = x/*0:01*/!=bigint y/*0:1*/;
+x/*0:01*/::bigint+y/*0:1*/::double = double x/*0:01*/+y/*0:1*/;
+x/*0:01*/::bigint-y/*0:1*/::double = double x/*0:01*/-y/*0:1*/;
+x/*0:01*/::bigint*y/*0:1*/::double = double x/*0:01*/*y/*0:1*/;
+x/*0:01*/::bigint/y/*0:1*/::double = double x/*0:01*//y/*0:1*/;
+x/*0:01*/::bigint<y/*0:1*/::double = double x/*0:01*/<y/*0:1*/;
+x/*0:01*/::bigint>y/*0:1*/::double = double x/*0:01*/>y/*0:1*/;
+x/*0:01*/::bigint<=y/*0:1*/::double = double x/*0:01*/<=y/*0:1*/;
+x/*0:01*/::bigint>=y/*0:1*/::double = double x/*0:01*/>=y/*0:1*/;
+x/*0:01*/::bigint==y/*0:1*/::double = double x/*0:01*/==y/*0:1*/;
+x/*0:01*/::bigint!=y/*0:1*/::double = double x/*0:01*/!=y/*0:1*/;
+x/*0:01*/::double+y/*0:1*/::bigint = x/*0:01*/+double y/*0:1*/;
+x/*0:01*/::double-y/*0:1*/::bigint = x/*0:01*/-double y/*0:1*/;
+x/*0:01*/::double*y/*0:1*/::bigint = x/*0:01*/*double y/*0:1*/;
+x/*0:01*/::double/y/*0:1*/::bigint = x/*0:01*//double y/*0:1*/;
+x/*0:01*/::double<y/*0:1*/::bigint = x/*0:01*/<double y/*0:1*/;
+x/*0:01*/::double>y/*0:1*/::bigint = x/*0:01*/>double y/*0:1*/;
+x/*0:01*/::double<=y/*0:1*/::bigint = x/*0:01*/<=double y/*0:1*/;
+x/*0:01*/::double>=y/*0:1*/::bigint = x/*0:01*/>=double y/*0:1*/;
+x/*0:01*/::double==y/*0:1*/::bigint = x/*0:01*/==double y/*0:1*/;
+x/*0:01*/::double!=y/*0:1*/::bigint = x/*0:01*/!=double y/*0:1*/;
+pow x/*0:01*/::bigint y/*0:1*/::int = bigint_pow x/*0:01*/ y/*0:1*/ if y/*0:1*/>=0;
+pow x/*0:01*/::int y/*0:1*/::int = bigint_pow (bigint x/*0:01*/) y/*0:1*/ if y/*0:1*/>=0;
+pow x/*0:01*/::bigint y/*0:1*/::bigint = bigint_pow x/*0:01*/ (int y/*0:1*/) if int y/*0:1*/>=0;
+null x/*0:1*/ = bigint x/*0:1*/==0;
+x/*0:01*/-y/*0:1*/ = bigint x/*0:01*/-bigint y/*0:1*/;
+x/*0:01*/+y/*0:1*/::int = pointer (bigint x/*0:01*/+y/*0:1*/);
+x/*0:01*/+y/*0:1*/::bigint = pointer (bigint x/*0:01*/+y/*0:1*/);
+x/*0:01*/<y/*0:1*/ = bigint x/*0:01*/<bigint y/*0:1*/;
+x/*0:01*/>y/*0:1*/ = bigint x/*0:01*/>bigint y/*0:1*/;
+x/*0:01*/<=y/*0:1*/ = bigint x/*0:01*/<=bigint y/*0:1*/;
+x/*0:01*/>=y/*0:1*/ = bigint x/*0:01*/>=bigint y/*0:1*/;
+x/*0:01*/==y/*0:1*/ = bigint x/*0:01*/==bigint y/*0:1*/;
+x/*0:01*/!=y/*0:1*/ = bigint x/*0:01*/!=bigint y/*0:1*/;
+get_byte x/*0:1*/ = pointer_get_byte x/*0:1*/;
+get_int x/*0:1*/ = pointer_get_int x/*0:1*/;
+get_double x/*0:1*/ = pointer_get_double x/*0:1*/;
+get_string x/*0:1*/ = pointer_get_string x/*0:1*/;
+get_pointer x/*0:1*/ = pointer_get_pointer x/*0:1*/;
+put_byte x/*0:01*/ y/*0:1*/::int = pointer_put_byte x/*0:01*/ y/*0:1*/;
+put_int x/*0:01*/ y/*0:1*/::int = pointer_put_int x/*0:01*/ y/*0:1*/;
+put_double x/*0:01*/ y/*0:1*/::double = pointer_put_double x/*0:01*/ y/*0:1*/;
+put_string x/*0:01*/ y/*0:1*/::string = pointer_put_string x/*0:01*/ y/*0:1*/;
+put_pointer x/*0:01*/ y/*0:1*/::string = pointer_put_pointer x/*0:01*/ y/*0:1*/;
+put_pointer x/*0:01*/ y/*0:1*/ = pointer_put_pointer x/*0:01*/ y/*0:1*/;
+chr n/*0:1*/::int = string_chr n/*0:1*/ if n/*0:1*/>0;
+ord s/*0:1*/::string = string_ord s/*0:1*/ if #s/*0:1*/==1;
+string s/*0:1*/ = pure_string s/*0:1*/;
+cstring s/*0:1*/ = pure_cstring s/*0:1*/;
+string_dup s/*0:1*/ = pure_string_dup s/*0:1*/;
+cstring_dup s/*0:1*/ = pure_cstring_dup s/*0:1*/;
+byte_string s/*0:1*/::string = pure_byte_string s/*0:1*/;
+byte_cstring s/*0:1*/::string = pure_byte_cstring s/*0:1*/;
+c/*0:01*/::string+n/*0:1*/::int = chr (ord c/*0:01*/+n/*0:1*/) if #c/*0:01*/==1;
+c/*0:01*/::string-n/*0:1*/::int = chr (ord c/*0:01*/-n/*0:1*/) if #c/*0:01*/==1&&ord c/*0:01*/>=n/*0:1*/;
+c/*0:01*/::string-d/*0:1*/::string = ord c/*0:01*/-ord d/*0:1*/ if #c/*0:01*/==1&&#d/*0:1*/==1;
+null s/*0:1*/::string = string_null s/*0:1*/;
+#s/*0:1*/::string = string_size s/*0:1*/;
+s/*0:01*/::string!n/*0:1*/::int = string_char_at s/*0:01*/ n/*0:1*/ if n/*0:1*/>=0&&n/*0:1*/<#s/*0:01*/;
+s/*0:01*/::string+t/*0:1*/::string = string_concat s/*0:01*/ t/*0:1*/;
+chars s/*0:1*/::string = string_chars s/*0:1*/;
+x/*0:01*/::string<y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/<0;
+x/*0:01*/::string>y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/>0;
+x/*0:01*/::string<=y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/<=0;
+x/*0:01*/::string>=y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/>=0;
+x/*0:01*/::string==y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/==0;
+x/*0:01*/::string!=y/*0:1*/::string = strcmp x/*0:01*/ y/*0:1*/!=0;
+substr s/*0:001*/::string pos/*0:01*/::int size/*0:1*/::int = string_substr s/*0:001*/ (max/*0*/ 0 pos/*0:01*/) (max/*0*/ 0 size/*0:1*/) with max x/*0:01*/ y/*0:1*/ = if x/*0:01*/>=y/*0:1*/ then x/*0:01*/ else y/*0:1*/ {
+ rule #0: max x y = if x>=y then x else y
+ state 0: #0
+ <var> state 1
+ state 1: #0
+ <var> state 2
+ state 2: #0
+} end;
+index s/*0:01*/::string u/*0:1*/::string = string_index s/*0:01*/ u/*0:1*/;
+strcat xs/*0:1*/ = string_concat_list xs/*0:1*/ if listp xs/*0:1*/&&all stringp xs/*0:1*/;
+join delim/*0:01*/::string [] = "";
+join delim/*0:01*/::string (x/*0:101*/::string:xs/*0:11*/) = x/*0:101*/+strcat (catmap (\x/*0:*/ -> [delim/*1:01*/+x/*0:*/] {
+ rule #0: x = [delim+x]
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}) xs/*0:11*/) if listp xs/*0:11*/&&all stringp xs/*0:11*/;
+split delim/*0:01*/::string s/*0:1*/::string = if null s/*1:1*/ then [] else split1/*0*/ delim/*1:01*/ s/*1:1*/ with split1 delim/*0:01*/ s/*0:1*/ = case index s/*0:1*/ delim/*0:01*/ of n/*0:*/ = take n/*0:*/ s/*1:1*/:split1/*2*/ delim/*1:01*/ (drop (n/*0:*/+m/*2:*/) s/*1:1*/) if n/*0:*/>=0; n/*0:*/ = [s/*1:1*/] {
+ rule #0: n = take n s:split1 delim (drop (n+m) s) if n>=0
+ rule #1: n = [s]
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end {
+ rule #0: split1 delim s = case index s delim of n = take n s:split1 delim (drop (n+m) s) if n>=0; n = [s] end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+ <var> state 2
+ state 2: #0
+} end when m/*0:*/ = #delim/*0:01*/ {
+ rule #0: m = #delim
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end if not null delim/*0:01*/;
+reverse s/*0:1*/::string = strcat (reverse (chars s/*0:1*/));
+cat (s/*0:101*/::string:xs/*0:11*/) = cat (chars s/*0:101*/:xs/*0:11*/);
+all p/*0:01*/ s/*0:1*/::string = all p/*0:01*/ (chars s/*0:1*/);
+any p/*0:01*/ s/*0:1*/::string = any p/*0:01*/ (chars s/*0:1*/);
+do f/*0:01*/ s/*0:1*/::string = do f/*0:01*/ (chars s/*0:1*/);
+drop n/*0:01*/ s/*0:1*/::string = substr s/*0:1*/ n/*0:01*/ (#s/*0:1*/-n/*0:01*/);
+dropwhile p/*0:01*/ s/*0:1*/::string = strcat (dropwhile p/*0:01*/ (chars s/*0:1*/));
+filter p/*0:01*/ s/*0:1*/::string = strcat (filter p/*0:01*/ (chars s/*0:1*/));
+foldl f/*0:001*/ a/*0:01*/ s/*0:1*/::string = foldl f/*0:001*/ a/*0:01*/ (chars s/*0:1*/);
+foldl1 f/*0:01*/ s/*0:1*/::string = foldl1 f/*0:01*/ (chars s/*0:1*/);
+foldr f/*0:001*/ a/*0:01*/ s/*0:1*/::string = foldr f/*0:001*/ a/*0:01*/ (chars s/*0:1*/);
+foldr1 f/*0:01*/ s/*0:1*/::string = foldr1 f/*0:01*/ (chars s/*0:1*/);
+head s/*0:1*/::string = s/*0:1*/!0 if not null s/*0:1*/;
+init s/*0:1*/::string = substr s/*0:1*/ 0 (#s/*0:1*/-1) if not null s/*0:1*/;
+last s/*0:1*/::string = s/*0:1*/!(#s/*0:1*/-1) if not null s/*0:1*/;
+map f/*0:01*/ s/*0:1*/::string = map f/*0:01*/ (chars s/*0:1*/);
+scanl f/*0:001*/ a/*0:01*/ s/*0:1*/::string = scanl f/*0:001*/ a/*0:01*/ (chars s/*0:1*/);
+scanl1 f/*0:01*/ s/*0:1*/::string = scanl1 f/*0:01*/ (chars s/*0:1*/);
+scanr f/*0:001*/ a/*0:01*/ s/*0:1*/::string = scanr f/*0:001*/ a/*0:01*/ (chars s/*0:1*/);
+scanr1 f/*0:01*/ s/*0:1*/::string = scanr1 f/*0:01*/ (chars s/*0:1*/);
+take n/*0:01*/ s/*0:1*/::string = substr s/*0:1*/ 0 n/*0:01*/;
+takewhile p/*0:01*/ s/*0:1*/::string = strcat (takewhile p/*0:01*/ (chars s/*0:1*/));
+tail s/*0:1*/::string = substr s/*0:1*/ 1 (#s/*0:1*/-1) if not null s/*0:1*/;
+zip s/*0:01*/::string t/*0:1*/::string = zip (chars s/*0:01*/) (chars t/*0:1*/);
+zip3 s/*0:001*/::string t/*0:01*/::string u/*0:1*/::string = zip3 (chars s/*0:001*/) (chars t/*0:01*/) (chars u/*0:1*/);
+zipwith f/*0:001*/ s/*0:01*/::string t/*0:1*/::string = zipwith f/*0:001*/ (chars s/*0:01*/) (chars t/*0:1*/);
+zipwith3 f/*0:0001*/ s/*0:001*/::string t/*0:01*/::string u/*0:1*/::string = zipwith3 f/*0:0001*/ (chars s/*0:001*/) (chars t/*0:01*/) (chars u/*0:1*/);
+dowith f/*0:001*/ s/*0:01*/::string t/*0:1*/::string = dowith f/*0:001*/ (chars s/*0:01*/) (chars t/*0:1*/);
+dowith3 f/*0:0001*/ s/*0:001*/::string t/*0:01*/::string u/*0:1*/::string = dowith3 f/*0:0001*/ (chars s/*0:001*/) (chars t/*0:01*/) (chars u/*0:1*/);
+f/*0:01*/$x/*0:1*/ = f/*0:01*/ x/*0:1*/;
+(f/*0:001*/.g/*0:01*/) x/*0:1*/ = f/*0:001*/ (g/*0:01*/ x/*0:1*/);
+void _/*0:1*/ = ();
+id x/*0:1*/ = x/*0:1*/;
+const x/*0:01*/ y/*0:1*/ = x/*0:01*/;
+flip f/*0:001*/ x/*0:01*/ y/*0:1*/ = f/*0:001*/ y/*0:1*/ x/*0:01*/;
+curry f/*0:001*/ x/*0:01*/ y/*0:1*/ = f/*0:001*/ (x/*0:01*/,y/*0:1*/);
+curry3 f/*0:0001*/ x/*0:001*/ y/*0:01*/ z/*0:1*/ = f/*0:0001*/ (x/*0:001*/,y/*0:01*/,z/*0:1*/);
+uncurry f/*0:01*/ (x/*0:101*/,y/*0:11*/) = f/*0:01*/ x/*0:101*/ y/*0:11*/;
+uncurry3 f/*0:01*/ (x/*0:101*/,y/*0:1101*/,z/*0:111*/) = f/*0:01*/ x/*0:101*/ y/*0:1101*/ z/*0:111*/;
+x/*0:01*/,() = x/*0:01*/;
+(),y/*0:1*/ = y/*0:1*/;
+(x/*0:0101*/,y/*0:011*/),z/*0:1*/ = x/*0:0101*/,y/*0:011*/,z/*0:1*/;
+()==() = 1;
+(x/*0:0101*/,xs/*0:011*/)==() = 0;
+()==(x/*0:101*/,xs/*0:11*/) = 0;
+(x/*0:0101*/,xs/*0:011*/)==(y/*0:101*/,ys/*0:11*/) = x/*0:0101*/==y/*0:101*/&&xs/*0:011*/==ys/*0:11*/;
+()!=() = 0;
+(x/*0:0101*/,xs/*0:011*/)!=() = 1;
+()!=(x/*0:101*/,xs/*0:11*/) = 1;
+(x/*0:0101*/,xs/*0:011*/)!=(y/*0:101*/,ys/*0:11*/) = x/*0:0101*/!=y/*0:101*/||xs/*0:011*/!=ys/*0:11*/;
+null () = 1;
+null (x/*0:101*/,xs/*0:11*/) = 0;
+#() = 0;
+#(x/*0:101*/,y/*0:1101*/,xs/*0:111*/) = 1+#(y/*0:1101*/,xs/*0:111*/);
+#(x/*0:101*/,y/*0:11*/) = 2;
+(x/*0:0101*/,xs/*0:011*/)!0 = x/*0:0101*/;
+(x/*0:0101*/,y/*0:01101*/,xs/*0:0111*/)!n/*0:1*/::int = (y/*0:01101*/,xs/*0:0111*/)!(n/*0:1*/-1) if n/*0:1*/>0;
+(x/*0:0101*/,y/*0:011*/)!1 = y/*0:011*/;
+[]==[] = 1;
+x/*0:0101*/:xs/*0:011*/==[] = 0;
+[]==x/*0:101*/:xs/*0:11*/ = 0;
+x/*0:0101*/:xs/*0:011*/==y/*0:101*/:ys/*0:11*/ = x/*0:0101*/==y/*0:101*/&&xs/*0:011*/==ys/*0:11*/;
+[]!=[] = 0;
+x/*0:0101*/:xs/*0:011*/!=[] = 1;
+[]!=x/*0:101*/:xs/*0:11*/ = 1;
+x/*0:0101*/:xs/*0:011*/!=y/*0:101*/:ys/*0:11*/ = x/*0:0101*/!=y/*0:101*/||xs/*0:011*/!=ys/*0:11*/;
+null [] = 1;
+null (x/*0:101*/:xs/*0:11*/) = 0;
+#[] = 0;
+#(x/*0:101*/:xs/*0:11*/) = 1+#xs/*0:11*/;
+(x/*0:0101*/:xs/*0:011*/)!0 = x/*0:0101*/;
+(x/*0:0101*/:xs/*0:011*/)!n/*0:1*/::int = xs/*0:011*/!(n/*0:1*/-1) if n/*0:1*/>0;
+[]+ys/*0:1*/ = ys/*0:1*/;
+(x/*0:0101*/:xs/*0:011*/)+ys/*0:1*/ = x/*0:0101*/:xs/*0:011*/+ys/*0:1*/;
+list () = [];
+list (x/*0:101*/,y/*0:1101*/,xs/*0:111*/) = x/*0:101*/:list (y/*0:1101*/,xs/*0:111*/);
+list (x/*0:101*/,y/*0:11*/) = [x/*0:101*/,y/*0:11*/];
+tuple [] = ();
+tuple [x/*0:101*/] = x/*0:101*/;
+tuple (x/*0:101*/:y/*0:1101*/:xs/*0:111*/) = x/*0:101*/,tuple (y/*0:1101*/:xs/*0:111*/);
+xs/*0:01*/![] = [];
+xs/*0:01*/!(n/*0:101*/::int:ns/*0:11*/) = slice/*0*/ xs/*1:01*/ (n/*1:101*/:ns/*1:11*/) with slice xs/*0:01*/ [] = []; slice xs/*0:01*/ (n/*0:101*/::int:ns/*0:11*/) = xs/*0:01*/!n/*0:101*/:slice/*1*/ xs/*0:01*/ ns/*0:11*/ if n/*0:101*/>=0&&n/*0:101*/<m/*1:*/; slice xs/*0:01*/ (n/*0:101*/::int:ns/*0:11*/) = xs/*0:01*/!ns/*0:11*/ {
+ rule #0: slice xs [] = []
+ rule #1: slice xs (n::int:ns) = xs!n:slice xs ns if n>=0&&n<m
+ rule #2: slice xs (n::int:ns) = xs!ns
+ state 0: #0 #1 #2
+ <var> state 1
+ state 1: #0 #1 #2
+ [] state 2
+ <app> state 3
+ state 2: #0
+ state 3: #1 #2
+ <app> state 4
+ state 4: #1 #2
+ : state 5
+ state 5: #1 #2
+ <var>::int state 6
+ state 6: #1 #2
+ <var> state 7
+ state 7: #1 #2
+} end when m/*0:*/::int = #xs/*0:01*/ {
+ rule #0: m::int = #xs
+ state 0: #0
+ <var>::int state 1
+ state 1: #0
+} end;
+n1/*0:0101*/,n2/*0:011*/..m/*0:1*/ = while (\i/*0:*/ -> s/*1:*/*i/*0:*/<=s/*1:*/*m/*3:1*/ {
+ rule #0: i = s*i<=s*m
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}) (\x/*0:*/ -> x/*0:*/+k/*2:*/ {
+ rule #0: x = x+k
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}) n1/*2:0101*/ when k/*0:*/ = n2/*0:011*/-n1/*0:0101*/; s/*0:*/ = if k/*0:*/>0 then 1 else -1 {
+ rule #0: s = if k>0 then 1 else -1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} {
+ rule #0: k = n2-n1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end if n1/*0:0101*/!=n2/*0:011*/;
+n/*0:01*/..m/*0:1*/ = while (\i/*0:*/ -> i/*0:*/<=m/*1:1*/ {
+ rule #0: i = i<=m
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}) (\x/*0:*/ -> x/*0:*/+1 {
+ rule #0: x = x+1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}) n/*0:01*/;
+all p/*0:01*/ [] = 1;
+all p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = p/*0:01*/ x/*0:101*/&&all p/*0:01*/ xs/*0:11*/;
+any p/*0:01*/ [] = 0;
+any p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = p/*0:01*/ x/*0:101*/||any p/*0:01*/ xs/*0:11*/;
+do f/*0:01*/ [] = ();
+do f/*0:01*/ (x/*0:101*/:xs/*0:11*/) = do f/*1:01*/ xs/*1:11*/ when _/*0:*/ = f/*0:01*/ x/*0:101*/ {
+ rule #0: _ = f x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+drop n/*0:01*/ [] = [];
+drop n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = drop (n/*0:01*/-1) xs/*0:11*/ if n/*0:01*/>0;
+drop n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:xs/*0:11*/;
+dropwhile p/*0:01*/ [] = [];
+dropwhile p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = dropwhile p/*0:01*/ xs/*0:11*/ if p/*0:01*/ x/*0:101*/;
+dropwhile p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:xs/*0:11*/;
+filter p/*0:01*/ [] = [];
+filter p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:filter p/*0:01*/ xs/*0:11*/ if p/*0:01*/ x/*0:101*/;
+filter p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = filter p/*0:01*/ xs/*0:11*/;
+foldl f/*0:001*/ a/*0:01*/ [] = a/*0:01*/;
+foldl f/*0:001*/ a/*0:01*/ (x/*0:101*/:xs/*0:11*/) = foldl f/*0:001*/ (f/*0:001*/ a/*0:01*/ x/*0:101*/) xs/*0:11*/;
+foldl1 f/*0:01*/ (x/*0:101*/:xs/*0:11*/) = foldl f/*0:01*/ x/*0:101*/ xs/*0:11*/;
+foldr f/*0:001*/ a/*0:01*/ [] = a/*0:01*/;
+foldr f/*0:001*/ a/*0:01*/ (x/*0:101*/:xs/*0:11*/) = f/*0:001*/ x/*0:101*/ (foldr f/*0:001*/ a/*0:01*/ xs/*0:11*/);
+foldr1 f/*0:01*/ [x/*0:101*/] = x/*0:101*/;
+foldr1 f/*0:01*/ (x/*0:101*/:y/*0:1101*/:xs/*0:111*/) = f/*0:01*/ x/*0:101*/ (foldr1 f/*0:01*/ (y/*0:1101*/:xs/*0:111*/));
+head (x/*0:101*/:xs/*0:11*/) = x/*0:101*/;
+init [x/*0:101*/] = [];
+init (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:init xs/*0:11*/;
+last [x/*0:101*/] = x/*0:101*/;
+last (x/*0:101*/:xs/*0:11*/) = last xs/*0:11*/;
+map f/*0:01*/ [] = [];
+map f/*0:01*/ (x/*0:101*/:xs/*0:11*/) = f/*0:01*/ x/*0:101*/:map f/*0:01*/ xs/*0:11*/;
+scanl f/*0:001*/ a/*0:01*/ [] = [a/*0:01*/];
+scanl f/*0:001*/ a/*0:01*/ (x/*0:101*/:xs/*0:11*/) = a/*0:01*/:scanl f/*0:001*/ (f/*0:001*/ a/*0:01*/ x/*0:101*/) xs/*0:11*/;
+scanl1 f/*0:01*/ [] = [];
+scanl1 f/*0:01*/ (x/*0:101*/:xs/*0:11*/) = scanl f/*0:01*/ x/*0:101*/ xs/*0:11*/;
+scanr f/*0:001*/ a/*0:01*/ [] = [a/*0:01*/];
+scanr f/*0:001*/ a/*0:01*/ (x/*0:101*/:xs/*0:11*/) = f/*2:001*/ x/*2:101*/ y/*0:01*/:ys/*1:*/ when ys/*0:*/ = scanr f/*0:001*/ a/*0:01*/ xs/*0:11*/; y/*0:01*/:_/*0:1*/ = ys/*0:*/ {
+ rule #0: y:_ = ys
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ : state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} {
+ rule #0: ys = scanr f a xs
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+scanr1 f/*0:01*/ [] = [];
+scanr1 f/*0:01*/ [x/*0:101*/] = [x/*0:101*/];
+scanr1 f/*0:01*/ (x/*0:101*/:xs/*0:11*/) = f/*2:01*/ x/*2:101*/ y/*0:01*/:ys/*1:*/ when ys/*0:*/ = scanr1 f/*0:01*/ xs/*0:11*/; y/*0:01*/:_/*0:1*/ = ys/*0:*/ {
+ rule #0: y:_ = ys
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ : state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} {
+ rule #0: ys = scanr1 f xs
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+tail (x/*0:101*/:xs/*0:11*/) = xs/*0:11*/;
+take n/*0:01*/ [] = [];
+take n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:take (n/*0:01*/-1) xs/*0:11*/ if n/*0:01*/>0;
+take n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = [];
+takewhile p/*0:01*/ [] = [];
+takewhile p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = x/*0:101*/:takewhile p/*0:01*/ xs/*0:11*/ if p/*0:01*/ x/*0:101*/;
+takewhile p/*0:01*/ (x/*0:101*/:xs/*0:11*/) = [];
+cat [] = [];
+cat (xs/*0:101*/:xss/*0:11*/) = accum/*0*/ (reverse xs/*0:101*/) xss/*0:11*/ with accum xs/*0:01*/ [] = reverse xs/*0:01*/; accum xs/*0:01*/ ([]:yss/*0:11*/) = accum/*1*/ xs/*0:01*/ yss/*0:11*/; accum xs/*0:01*/ ((y/*0:10101*/:ys/*0:1011*/):yss/*0:11*/) = accum/*1*/ (y/*0:10101*/:xs/*0:01*/) (ys/*0:1011*/:yss/*0:11*/); accum xs/*0:01*/ yss/*0:1*/ = reverse xs/*0:01*/+cat yss/*0:1*/ {
+ rule #0: accum xs [] = reverse xs
+ rule #1: accum xs ([]:yss) = accum xs yss
+ rule #2: accum xs ((y:ys):yss) = accum (y:xs) (ys:yss)
+ rule #3: accum xs yss = reverse xs+cat yss
+ state 0: #0 #1 #2 #3
+ <var> state 1
+ state 1: #0 #1 #2 #3
+ <var> state 2
+ [] state 3
+ <app> state 4
+ state 2: #3
+ state 3: #0 #3
+ state 4: #1 #2 #3
+ <var> state 5
+ <app> state 7
+ state 5: #3
+ <var> state 6
+ state 6: #3
+ state 7: #1 #2 #3
+ <var> state 8
+ : state 11
+ state 8: #3
+ <var> state 9
+ state 9: #3
+ <var> state 10
+ state 10: #3
+ state 11: #1 #2 #3
+ <var> state 12
+ [] state 14
+ <app> state 16
+ state 12: #3
+ <var> state 13
+ state 13: #3
+ state 14: #1 #3
+ <var> state 15
+ state 15: #1 #3
+ state 16: #2 #3
+ <var> state 17
+ <app> state 20
+ state 17: #3
+ <var> state 18
+ state 18: #3
+ <var> state 19
+ state 19: #3
+ state 20: #2 #3
+ <var> state 21
+ : state 25
+ state 21: #3
+ <var> state 22
+ state 22: #3
+ <var> state 23
+ state 23: #3
+ <var> state 24
+ state 24: #3
+ state 25: #2 #3
+ <var> state 26
+ state 26: #2 #3
+ <var> state 27
+ state 27: #2 #3
+ <var> state 28
+ state 28: #2 #3
+} end if listp xs/*0:101*/;
+catmap f/*0:01*/ xs/*0:1*/ = cat (map f/*0:01*/ xs/*0:1*/);
+reverse xs/*0:1*/ = foldl (flip (:)) [] xs/*0:1*/ if listp xs/*0:1*/;
+repeat n/*0:01*/ x/*0:1*/ = [] if n/*0:01*/<=0;
+repeat n/*0:01*/ x/*0:1*/ = x/*0:1*/:repeat (n/*0:01*/-1) x/*0:1*/;
+cycle n/*0:01*/ [] = [];
+cycle n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = [] if n/*0:01*/<=0;
+cycle n/*0:01*/ (x/*0:101*/:xs/*0:11*/) = mkcycle/*0*/ n/*2:01*/ xs/*1:*/ with mkcycle n/*0:01*/ xs/*0:1*/ = take n/*0:01*/ xs/*0:1*/ if n/*0:01*/<=m/*1:*/; mkcycle n/*0:01*/ xs/*0:1*/ = xs/*0:1*/+mkcycle/*1*/ (n/*0:01*/-m/*1:*/) xs/*0:1*/ {
+ rule #0: mkcycle n xs = take n xs if n<=m
+ rule #1: mkcycle n xs = xs+mkcycle (n-m) xs
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+ <var> state 2
+ state 2: #0 #1
+} end when xs/*0:*/ = x/*0:101*/:xs/*0:11*/; m/*0:*/ = #xs/*0:*/ {
+ rule #0: m = #xs
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} {
+ rule #0: xs = x:xs
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+while p/*0:001*/ f/*0:01*/ a/*0:1*/ = a/*0:1*/:while p/*0:001*/ f/*0:01*/ (f/*0:01*/ a/*0:1*/) if p/*0:001*/ a/*0:1*/;
+while p/*0:001*/ f/*0:01*/ a/*0:1*/ = [];
+until p/*0:001*/ f/*0:01*/ a/*0:1*/ = [] if p/*0:001*/ a/*0:1*/;
+until p/*0:001*/ f/*0:01*/ a/*0:1*/ = a/*0:1*/:until p/*0:001*/ f/*0:01*/ (f/*0:01*/ a/*0:1*/);
+zip (x/*0:0101*/:xs/*0:011*/) (y/*0:101*/:ys/*0:11*/) = (x/*0:0101*/,y/*0:101*/):zip xs/*0:011*/ ys/*0:11*/;
+zip _/*0:01*/ _/*0:1*/ = [];
+zip3 (x/*0:00101*/:xs/*0:0011*/) (y/*0:0101*/:ys/*0:011*/) (z/*0:101*/:zs/*0:11*/) = (x/*0:00101*/,y/*0:0101*/,z/*0:101*/):zip3 xs/*0:0011*/ ys/*0:011*/ zs/*0:11*/;
+zip3 _/*0:001*/ _/*0:01*/ _/*0:1*/ = [];
+zipwith f/*0:001*/ (x/*0:0101*/:xs/*0:011*/) (y/*0:101*/:ys/*0:11*/) = f/*0:001*/ x/*0:0101*/ y/*0:101*/:zipwith f/*0:001*/ xs/*0:011*/ ys/*0:11*/;
+zipwith f/*0:001*/ _/*0:01*/ _/*0:1*/ = [];
+zipwith3 f/*0:0001*/ (x/*0:00101*/:xs/*0:0011*/) (y/*0:0101*/:ys/*0:011*/) (z/*0:101*/:zs/*0:11*/) = f/*0:0001*/ x/*0:00101*/ y/*0:0101*/ z/*0:101*/:zipwith3 f/*0:0001*/ xs/*0:0011*/ ys/*0:011*/ zs/*0:11*/;
+zipwith3 f/*0:0001*/ _/*0:001*/ _/*0:01*/ _/*0:1*/ = [];
+dowith f/*0:001*/ (x/*0:0101*/:xs/*0:011*/) (y/*0:101*/:ys/*0:11*/) = dowith f/*1:001*/ xs/*1:011*/ ys/*1:11*/ when _/*0:*/ = f/*0:001*/ x/*0:0101*/ y/*0:101*/ {
+ rule #0: _ = f x y
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+dowith f/*0:001*/ _/*0:01*/ _/*0:1*/ = ();
+dowith3 f/*0:0001*/ (x/*0:00101*/:xs/*0:0011*/) (y/*0:0101*/:ys/*0:011*/) (z/*0:101*/:zs/*0:11*/) = dowith3 f/*1:0001*/ xs/*1:0011*/ ys/*1:011*/ zs/*1:11*/ when _/*0:*/ = f/*0:0001*/ x/*0:00101*/ y/*0:0101*/ z/*0:101*/ {
+ rule #0: _ = f x y z
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+dowith3 f/*0:0001*/ _/*0:001*/ _/*0:01*/ _/*0:1*/ = ();
+unzip ((x/*0:10101*/,y/*0:1011*/):us/*0:11*/) = x/*1:10101*/:xs/*0:01*/,y/*1:1011*/:ys/*0:1*/ when xs/*0:01*/,ys/*0:1*/ = unzip us/*0:11*/ {
+ rule #0: xs,ys = unzip us
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end;
+unzip [] = [],[];
+unzip3 ((x/*0:10101*/,y/*0:101101*/,z/*0:10111*/):us/*0:11*/) = x/*1:10101*/:xs/*0:01*/,y/*1:101101*/:ys/*0:101*/,z/*1:10111*/:zs/*0:11*/ when xs/*0:01*/,ys/*0:101*/,zs/*0:11*/ = unzip3 us/*0:11*/ {
+ rule #0: xs,ys,zs = unzip3 us
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <app> state 5
+ state 5: #0
+ <app> state 6
+ state 6: #0
+ , state 7
+ state 7: #0
+ <var> state 8
+ state 8: #0
+ <var> state 9
+ state 9: #0
+} end;
+unzip3 [] = [],[],[];
Added: pure/trunk/test/test1.log
===================================================================
--- pure/trunk/test/test1.log (rev 0)
+++ pure/trunk/test/test1.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,182 @@
+square x/*0:1*/ = x/*0:1*/*x/*0:1*/;
+{
+ rule #0: square x = x*x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+square 5;
+25
+fact1 n/*0:1*/ = n/*0:1*/*fact1 (n/*0:1*/-1) if n/*0:1*/>0;
+fact1 n/*0:1*/ = 1;
+{
+ rule #0: fact1 n = n*fact1 (n-1) if n>0
+ rule #1: fact1 n = 1
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+{
+ rule #0: x = fact1 10
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+let x = fact1 10;
+fact2 n/*0:1*/ = case n/*0:1*/ of n/*0:*/ = n/*0:*/*fact2 (n/*0:*/-1) if n/*0:*/>0; n/*0:*/ = 1 {
+ rule #0: n = n*fact2 (n-1) if n>0
+ rule #1: n = 1
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fact3 n/*0:1*/ = case n/*0:1*/ of 0 = 1; n/*0:*/ = n/*0:*/*fact3 (n/*0:*/-1) if n/*0:*/>1 {
+ rule #0: 0 = 1
+ rule #1: n = n*fact3 (n-1) if n>1
+ state 0: #0 #1
+ <var> state 1
+ 0::int state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+fact4 n/*0:1*/ = if n/*0:1*/>0 then n/*0:1*/*fact4 (n/*0:1*/-1) else 1;
+fact5 = \n/*0:*/ -> if n/*0:*/>0 then n/*0:*/*fact5 (n/*0:*/-1) else 1 {
+ rule #0: n = if n>0 then n*fact5 (n-1) else 1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+};
+fact n/*0:1*/::int = fact (bigint n/*0:1*/);
+fact n/*0:1*/::bigint = n/*0:1*/*fact (n/*0:1*/-1) if n/*0:1*/>0;
+fact n/*0:1*/::bigint = 1;
+fib1 0 = 0;
+fib1 1 = 1;
+fib1 n/*0:1*/ = fib1 (n/*0:1*/-2)+fib1 (n/*0:1*/-1) if n/*0:1*/>1;
+fib2 n/*0:1*/ = case fibs/*0*/ n/*0:1*/ of a/*0:01*/,b/*0:1*/ = a/*0:01*/ {
+ rule #0: a,b = a
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = case fibs/*1*/ (n/*0:1*/-1) of a/*0:01*/,b/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ {
+ rule #0: a,b = b,a+b
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = case fibs (n-1) of a,b = b,a+b end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib3 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: fact2 n = case n of n = n*fact2 (n-1) if n>0; n = 1 end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact3 n = case n of 0 = 1; n = n*fact3 (n-1) if n>1 end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact4 n = if n>0 then n*fact4 (n-1) else 1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact5 = \n -> if n>0 then n*fact5 (n-1) else 1
+ state 0: #0
+}
+{
+ rule #0: fact n::int = fact (bigint n)
+ rule #1: fact n::bigint = n*fact (n-1) if n>0
+ rule #2: fact n::bigint = 1
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1 #2
+}
+{
+ rule #0: fib1 0 = 0
+ rule #1: fib1 1 = 1
+ rule #2: fib1 n = fib1 (n-2)+fib1 (n-1) if n>1
+ state 0: #0 #1 #2
+ <var> state 1
+ 0::int state 2
+ 1::int state 3
+ state 1: #2
+ state 2: #0 #2
+ state 3: #1 #2
+}
+{
+ rule #0: fib2 n = case fibs n of a,b = a end with fibs n = 0,1 if n<=0; fibs n = case fibs (n-1) of a,b = b,a+b end end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fib3 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+map fib1 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
+map fib2 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
+map fib3 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
Added: pure/trunk/test/test2.log
===================================================================
--- pure/trunk/test/test2.log (rev 0)
+++ pure/trunk/test/test2.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,63 @@
+fib n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ (0,1) n/*0:1*/ {
+ rule #0: a,b = fibs (0,1) n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = a/*0:0101*/,b/*0:011*/ if n/*0:1*/<=0; fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = fibs/*1*/ (b/*0:011*/,bigint a/*0:0101*/+b/*0:011*/) (n/*0:1*/-1) {
+ rule #0: fibs (a,b) n = a,b if n<=0
+ rule #1: fibs (a,b) n = fibs (b,bigint a+b) (n-1)
+ state 0: #0 #1
+ <app> state 1
+ state 1: #0 #1
+ <app> state 2
+ state 2: #0 #1
+ , state 3
+ state 3: #0 #1
+ <var> state 4
+ state 4: #0 #1
+ <var> state 5
+ state 5: #0 #1
+ <var> state 6
+ state 6: #0 #1
+} end;
Added: pure/trunk/test/test3.log
===================================================================
--- pure/trunk/test/test3.log (rev 0)
+++ pure/trunk/test/test3.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,20 @@
+fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0;
+fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when m/*0:*/ = n/*0:1*/-1; a/*0:01*/,b/*0:1*/ = fibs m/*0:*/ {
+ rule #0: a,b = fibs m
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} {
+ rule #0: m = n-1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
Added: pure/trunk/test/test4.log
===================================================================
--- pure/trunk/test/test4.log (rev 0)
+++ pure/trunk/test/test4.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,103 @@
+foo x/*0:1*/ = bar/*0*/ with bar = x/*1:1*/ {
+ rule #0: bar = x
+ state 0: #0
+} end;
+foo2 x/*0:1*/ = bar/*0*/ x/*0:1*/ with bar 99 = bar/*1*/ (x/*1:1*/+1) {
+ rule #0: bar 99 = bar (x+1)
+ state 0: #0
+ 99::int state 1
+ state 1: #0
+} end;
+foo3 x/*0:1*/ = bar/*0*/ with bar y/*0:1*/ = bar/*1*/ (y/*0:1*/+1) if y/*0:1*/==x/*1:1*/ {
+ rule #0: bar y = bar (y+1) if y==x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+{
+ rule #0: foo x = bar with bar = x end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: foo2 x = bar x with bar 99 = bar (x+1) end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: foo3 x = bar with bar y = bar (y+1) if y==x end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+foo 99;
+99
+foo2 99;
+bar 100
+foo2 98;
+bar 98
+foo3 99;
+bar
+foo3 99 98;
+bar 98
+foo3 99 99;
+bar 100
+loop = loop;
+count n/*0:1*/ = ct/*0*/ n/*0:1*/ with ct n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0; ct n/*0:1*/::int = ct/*1*/ (n/*0:1*/-1) {
+ rule #0: ct n::int = n if n<=0
+ rule #1: ct n::int = ct (n-1)
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: loop = loop
+ state 0: #0
+}
+{
+ rule #0: count n = ct n with ct n::int = n if n<=0; ct n::int = ct (n-1) end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+count 100;
+0
+count 10000000;
+0
+count2 n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0;
+count2 n/*0:1*/::int = count2 (n/*0:1*/-1);
+{
+ rule #0: count2 n::int = n if n<=0
+ rule #1: count2 n::int = count2 (n-1)
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+}
+count2 100;
+0
+count2 10000000;
+0
+test x/*0:1*/::int = t/*0*/ x/*0:1*/ with t n/*0:1*/::int = t/*1*/ (-n/*0:1*/) if n/*0:1*/<0; t n/*0:1*/::int = u/*0*/ (n/*0:1*/+2) with u _/*0:1*/ = n/*1:1*/+1 {
+ rule #0: u _ = n+1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end {
+ rule #0: t n::int = t (-n) if n<0
+ rule #1: t n::int = u (n+2) with u _ = n+1 end
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: test x::int = t x with t n::int = t (-n) if n<0; t n::int = u (n+2) with u _ = n+1 end end
+ state 0: #0
+ <var>::int state 1
+ state 1: #0
+}
+test 98;
+99
+test (-97);
+98
Added: pure/trunk/test/test5.log
===================================================================
--- pure/trunk/test/test5.log (rev 0)
+++ pure/trunk/test/test5.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,13 @@
+fact 0 = 1;
+fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
+{
+ rule #0: fact 0 = 1
+ rule #1: fact n = n*fact (n-1)
+ state 0: #0 #1
+ <var> state 1
+ 0::int state 2
+ state 1: #1
+ state 2: #0 #1
+}
+fact 4;
+24
Added: pure/trunk/test/test6.log
===================================================================
--- pure/trunk/test/test6.log (rev 0)
+++ pure/trunk/test/test6.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,11 @@
+fact n/*0:1*/ = 1 if n/*0:1*/==0;
+fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
+{
+ rule #0: fact n = 1 if n==0
+ rule #1: fact n = n*fact (n-1)
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+fact 4;
+24
Added: pure/trunk/test/test7.log
===================================================================
--- pure/trunk/test/test7.log (rev 0)
+++ pure/trunk/test/test7.log 2008-05-02 20:30:47 UTC (rev 31)
@@ -0,0 +1,19 @@
+{
+ rule #0: y = \a -> \b -> a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+let y = \a/*0:*/ -> \b/*0:*/ -> a/*1:*/+b/*0:*/ {
+ rule #0: b = a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} {
+ rule #0: a = \b -> a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+};
+y 1 5;
+6
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-05-08 22:20:15
|
Revision: 68
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=68&view=rev
Author: agraef
Date: 2008-05-08 15:20:08 -0700 (Thu, 08 May 2008)
Log Message:
-----------
Cosmetic changes.
Modified Paths:
--------------
pure/trunk/test/test2.log
pure/trunk/test/test2.pure
Modified: pure/trunk/test/test2.log
===================================================================
--- pure/trunk/test/test2.log 2008-05-08 22:00:36 UTC (rev 67)
+++ pure/trunk/test/test2.log 2008-05-08 22:20:08 UTC (rev 68)
@@ -31,8 +31,8 @@
<var> state 1
state 1: #0 #1
} end;
-fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ (0,1) n/*0:1*/ {
- rule #0: a,b = fibs (0,1) n
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ (0L,1L) n/*0:1*/ {
+ rule #0: a,b = fibs (0L,1L) n
state 0: #0
<app> state 1
state 1: #0
@@ -44,9 +44,9 @@
state 4: #0
<var> state 5
state 5: #0
-} end with fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = a/*0:0101*/,b/*0:011*/ if n/*0:1*/<=0; fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = fibs/*1*/ (b/*0:011*/,bigint a/*0:0101*/+b/*0:011*/) (n/*0:1*/-1) {
+} end with fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = a/*0:0101*/,b/*0:011*/ if n/*0:1*/<=0; fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = fibs/*1*/ (b/*0:011*/,a/*0:0101*/+b/*0:011*/) (n/*0:1*/-1) {
rule #0: fibs (a,b) n = a,b if n<=0
- rule #1: fibs (a,b) n = fibs (b,bigint a+b) (n-1)
+ rule #1: fibs (a,b) n = fibs (b,a+b) (n-1)
state 0: #0 #1
<app> state 1
state 1: #0 #1
Modified: pure/trunk/test/test2.pure
===================================================================
--- pure/trunk/test/test2.pure 2008-05-08 22:00:36 UTC (rev 67)
+++ pure/trunk/test/test2.pure 2008-05-08 22:20:08 UTC (rev 68)
@@ -6,7 +6,7 @@
// tail-recursive version, using bigints
-fib2 n = a when a, b = fibs (0, 1) n end
+fib2 n = a when a, b = fibs (0L, 1L) n end
with fibs (a, b) n = a, b if n<=0;
- = fibs (b, bigint a+b) (n-1) otherwise;
+ = fibs (b, a+b) (n-1) otherwise;
end;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-05-12 08:05:19
|
Revision: 77
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=77&view=rev
Author: agraef
Date: 2008-05-12 01:05:24 -0700 (Mon, 12 May 2008)
Log Message:
-----------
Add regression test for code generator bug fixed in previous revisions.
Added Paths:
-----------
pure/trunk/test/test9.log
pure/trunk/test/test9.pure
Added: pure/trunk/test/test9.log
===================================================================
--- pure/trunk/test/test9.log (rev 0)
+++ pure/trunk/test/test9.log 2008-05-12 08:05:24 UTC (rev 77)
@@ -0,0 +1,108 @@
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ rule #1: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+warning: rule never reduced: fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+map fib2 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
Added: pure/trunk/test/test9.pure
===================================================================
--- pure/trunk/test/test9.pure (rev 0)
+++ pure/trunk/test/test9.pure 2008-05-12 08:05:24 UTC (rev 77)
@@ -0,0 +1,11 @@
+fib2 n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+fib2 n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+map fib2 (1..10);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-05-23 01:24:15
|
Revision: 108
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=108&view=rev
Author: agraef
Date: 2008-05-22 18:24:21 -0700 (Thu, 22 May 2008)
Log Message:
-----------
Rename regression tests, so that they are executed in the right order.
Added Paths:
-----------
pure/trunk/test/test001.log
pure/trunk/test/test001.pure
pure/trunk/test/test002.log
pure/trunk/test/test002.pure
pure/trunk/test/test003.log
pure/trunk/test/test003.pure
pure/trunk/test/test004.log
pure/trunk/test/test004.pure
pure/trunk/test/test005.log
pure/trunk/test/test005.pure
pure/trunk/test/test006.log
pure/trunk/test/test006.pure
pure/trunk/test/test007.log
pure/trunk/test/test007.pure
pure/trunk/test/test008.log
pure/trunk/test/test008.pure
pure/trunk/test/test009.log
pure/trunk/test/test009.pure
pure/trunk/test/test010.log
pure/trunk/test/test010.pure
Removed Paths:
-------------
pure/trunk/test/test1.log
pure/trunk/test/test1.pure
pure/trunk/test/test10.log
pure/trunk/test/test10.pure
pure/trunk/test/test2.log
pure/trunk/test/test2.pure
pure/trunk/test/test3.log
pure/trunk/test/test3.pure
pure/trunk/test/test4.log
pure/trunk/test/test4.pure
pure/trunk/test/test5.log
pure/trunk/test/test5.pure
pure/trunk/test/test6.log
pure/trunk/test/test6.pure
pure/trunk/test/test7.log
pure/trunk/test/test7.pure
pure/trunk/test/test8.log
pure/trunk/test/test8.pure
pure/trunk/test/test9.log
pure/trunk/test/test9.pure
Copied: pure/trunk/test/test001.log (from rev 88, pure/trunk/test/test1.log)
===================================================================
--- pure/trunk/test/test001.log (rev 0)
+++ pure/trunk/test/test001.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,194 @@
+square x/*0:1*/ = x/*0:1*/*x/*0:1*/;
+{
+ rule #0: square x = x*x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+square 5;
+25
+fact1 n/*0:1*/ = n/*0:1*/*fact1 (n/*0:1*/-1) if n/*0:1*/>0;
+fact1 n/*0:1*/ = 1;
+{
+ rule #0: fact1 n = n*fact1 (n-1) if n>0
+ rule #1: fact1 n = 1
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+{
+ rule #0: x = fact1 10
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+let x = fact1 10;
+x;
+3628800
+fact2 n/*0:1*/ = case n/*0:1*/ of n/*0:*/ = n/*0:*/*fact2 (n/*0:*/-1) if n/*0:*/>0; n/*0:*/ = 1 {
+ rule #0: n = n*fact2 (n-1) if n>0
+ rule #1: n = 1
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fact3 n/*0:1*/ = case n/*0:1*/ of 0 = 1; n/*0:*/ = n/*0:*/*fact3 (n/*0:*/-1) if n/*0:*/>0 {
+ rule #0: 0 = 1
+ rule #1: n = n*fact3 (n-1) if n>0
+ state 0: #0 #1
+ <var> state 1
+ 0::int state 2
+ state 1: #1
+ state 2: #0 #1
+} end;
+fact4 n/*0:1*/ = if n/*0:1*/>0 then n/*0:1*/*fact4 (n/*0:1*/-1) else 1;
+fact5 = \n/*0:*/ -> if n/*0:*/>0 then n/*0:*/*fact5 (n/*0:*/-1) else 1 {
+ rule #0: n = if n>0 then n*fact5 (n-1) else 1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+};
+{
+ rule #0: fact2 n = case n of n = n*fact2 (n-1) if n>0; n = 1 end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact3 n = case n of 0 = 1; n = n*fact3 (n-1) if n>0 end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact4 n = if n>0 then n*fact4 (n-1) else 1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fact5 = \n -> if n>0 then n*fact5 (n-1) else 1
+ state 0: #0
+}
+fact2 10;
+3628800
+fact3 10;
+3628800
+fact4 10;
+3628800
+fact5 10;
+3628800
+fact n/*0:1*/::int = fact (bigint n/*0:1*/);
+fact n/*0:1*/::bigint = n/*0:1*/*fact (n/*0:1*/-1) if n/*0:1*/>0;
+fact n/*0:1*/::bigint = 1;
+{
+ rule #0: fact n::int = fact (bigint n)
+ rule #1: fact n::bigint = n*fact (n-1) if n>0
+ rule #2: fact n::bigint = 1
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1 #2
+}
+fact 50;
+30414093201713378043612608166064768844377641568960512000000000000L
+fib1 0 = 0;
+fib1 1 = 1;
+fib1 n/*0:1*/ = fib1 (n/*0:1*/-2)+fib1 (n/*0:1*/-1) if n/*0:1*/>1;
+fib2 n/*0:1*/ = case fibs/*0*/ n/*0:1*/ of a/*0:01*/,b/*0:1*/ = a/*0:01*/ {
+ rule #0: a,b = a
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = case fibs/*1*/ (n/*0:1*/-1) of a/*0:01*/,b/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ {
+ rule #0: a,b = b,a+b
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = case fibs (n-1) of a,b = b,a+b end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib3 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: fib1 0 = 0
+ rule #1: fib1 1 = 1
+ rule #2: fib1 n = fib1 (n-2)+fib1 (n-1) if n>1
+ state 0: #0 #1 #2
+ <var> state 1
+ 0::int state 2
+ 1::int state 3
+ state 1: #2
+ state 2: #0 #2
+ state 3: #1 #2
+}
+{
+ rule #0: fib2 n = case fibs n of a,b = a end with fibs n = 0,1 if n<=0; fibs n = case fibs (n-1) of a,b = b,a+b end end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: fib3 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+map fib1 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
+map fib2 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
+map fib3 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
Copied: pure/trunk/test/test001.pure (from rev 88, pure/trunk/test/test1.pure)
===================================================================
--- pure/trunk/test/test001.pure (rev 0)
+++ pure/trunk/test/test001.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,82 @@
+
+// A simple script with some function and variable definitions.
+// This is used to test the guts of the interpreter.
+
+square x = x*x;
+
+/* a multiline
+ comment */
+
+square 5;
+
+// Factorial, with guarded rules.
+
+fact1 n = n*fact1 (n-1) if n>0;
+ = 1 otherwise;
+
+let x = fact1 10; x;
+
+// Factorial, using case.
+
+fact2 n = case n of
+ n = n*fact2 (n-1) if n>0;
+ = 1 otherwise;
+ end;
+
+// Factorial, yet another one.
+
+fact3 n = case n of
+ 0 = 1;
+ n = n*fact3 (n-1) if n>0;
+ end;
+
+// Factorial, with if-then-else.
+
+fact4 n = if n>0 then n*fact4 (n-1) else 1;
+
+// Factorial, with lambda ("pointless style").
+
+fact5 = \n -> if n>0 then n*fact5 (n-1) else 1;
+
+fact2 10;
+fact3 10;
+fact4 10;
+fact5 10;
+
+// Factorial, using bigints.
+
+fact n::int = fact (bigint n);
+fact n::bigint = n*fact (n-1) if n>0;
+ = 1 otherwise;
+
+fact 50;
+
+// Fibonacci function, naive O(fib n) implementation.
+
+fib1 0 = 0;
+fib1 1 = 1;
+fib1 n = fib1 (n-2) + fib1 (n-1) if n>1;
+
+// Fibonacci function, O(n) implementation.
+
+fib2 n = case fibs n of
+ a, b = a;
+ end
+ with
+ fibs n = 0, 1 if n<=0;
+ = case fibs (n-1) of
+ a, b = b, a+b;
+ end otherwise;
+ end;
+
+// Fibonacci function, another O(N) implementation.
+
+fib3 n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+
+map fib1 (1..10);
+map fib2 (1..10);
+map fib3 (1..10);
Copied: pure/trunk/test/test002.log (from rev 88, pure/trunk/test/test2.log)
===================================================================
--- pure/trunk/test/test002.log (rev 0)
+++ pure/trunk/test/test002.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,63 @@
+fib n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ (0L,1L) n/*0:1*/ {
+ rule #0: a,b = fibs (0L,1L) n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = a/*0:0101*/,b/*0:011*/ if n/*0:1*/<=0; fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = fibs/*1*/ (b/*0:011*/,a/*0:0101*/+b/*0:011*/) (n/*0:1*/-1) {
+ rule #0: fibs (a,b) n = a,b if n<=0
+ rule #1: fibs (a,b) n = fibs (b,a+b) (n-1)
+ state 0: #0 #1
+ <app> state 1
+ state 1: #0 #1
+ <app> state 2
+ state 2: #0 #1
+ , state 3
+ state 3: #0 #1
+ <var> state 4
+ state 4: #0 #1
+ <var> state 5
+ state 5: #0 #1
+ <var> state 6
+ state 6: #0 #1
+} end;
Copied: pure/trunk/test/test002.pure (from rev 88, pure/trunk/test/test2.pure)
===================================================================
--- pure/trunk/test/test002.pure (rev 0)
+++ pure/trunk/test/test002.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,12 @@
+fib n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+
+// tail-recursive version, using bigints
+
+fib2 n = a when a, b = fibs (0L, 1L) n end
+ with fibs (a, b) n = a, b if n<=0;
+ = fibs (b, a+b) (n-1) otherwise;
+ end;
Copied: pure/trunk/test/test003.log (from rev 88, pure/trunk/test/test3.log)
===================================================================
--- pure/trunk/test/test003.log (rev 0)
+++ pure/trunk/test/test003.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,20 @@
+fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0;
+fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when m/*0:*/ = n/*0:1*/-1; a/*0:01*/,b/*0:1*/ = fibs m/*0:*/ {
+ rule #0: a,b = fibs m
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} {
+ rule #0: m = n-1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
Copied: pure/trunk/test/test003.pure (from rev 88, pure/trunk/test/test3.pure)
===================================================================
--- pure/trunk/test/test003.pure (rev 0)
+++ pure/trunk/test/test003.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,3 @@
+fibs n = 0, 1 if n<=0;
+ = b, a+b when m = n-1; a, b = fibs m end
+ otherwise;
Copied: pure/trunk/test/test004.log (from rev 88, pure/trunk/test/test4.log)
===================================================================
--- pure/trunk/test/test004.log (rev 0)
+++ pure/trunk/test/test004.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,99 @@
+foo x/*0:1*/ = bar/*0*/ with bar = x/*1:1*/ {
+ rule #0: bar = x
+ state 0: #0
+} end;
+foo2 x/*0:1*/ = bar/*0*/ x/*0:1*/ with bar 99 = bar/*1*/ (x/*1:1*/+1) {
+ rule #0: bar 99 = bar (x+1)
+ state 0: #0
+ 99::int state 1
+ state 1: #0
+} end;
+foo3 x/*0:1*/ = bar/*0*/ with bar y/*0:1*/ = bar/*1*/ (y/*0:1*/+1) if y/*0:1*/==x/*1:1*/ {
+ rule #0: bar y = bar (y+1) if y==x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+{
+ rule #0: foo x = bar with bar = x end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: foo2 x = bar x with bar 99 = bar (x+1) end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: foo3 x = bar with bar y = bar (y+1) if y==x end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+foo 99;
+99
+foo2 99;
+bar 100
+foo2 98;
+bar 98
+foo3 99;
+bar
+foo3 99 98;
+bar 98
+foo3 99 99;
+bar 100
+loop = loop;
+count n/*0:1*/ = ct/*0*/ n/*0:1*/ with ct n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0; ct n/*0:1*/::int = ct/*1*/ (n/*0:1*/-1) {
+ rule #0: ct n::int = n if n<=0
+ rule #1: ct n::int = ct (n-1)
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: loop = loop
+ state 0: #0
+}
+{
+ rule #0: count n = ct n with ct n::int = n if n<=0; ct n::int = ct (n-1) end
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+count 100;
+0
+count2 n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0;
+count2 n/*0:1*/::int = count2 (n/*0:1*/-1);
+{
+ rule #0: count2 n::int = n if n<=0
+ rule #1: count2 n::int = count2 (n-1)
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+}
+count2 100;
+0
+test x/*0:1*/::int = t/*0*/ x/*0:1*/ with t n/*0:1*/::int = t/*1*/ (-n/*0:1*/) if n/*0:1*/<0; t n/*0:1*/::int = u/*0*/ (n/*0:1*/+2) with u _/*0:1*/ = n/*1:1*/+1 {
+ rule #0: u _ = n+1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end {
+ rule #0: t n::int = t (-n) if n<0
+ rule #1: t n::int = u (n+2) with u _ = n+1 end
+ state 0: #0 #1
+ <var>::int state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: test x::int = t x with t n::int = t (-n) if n<0; t n::int = u (n+2) with u _ = n+1 end end
+ state 0: #0
+ <var>::int state 1
+ state 1: #0
+}
+test 98;
+99
+test (-97);
+98
Copied: pure/trunk/test/test004.pure (from rev 88, pure/trunk/test/test4.pure)
===================================================================
--- pure/trunk/test/test004.pure (rev 0)
+++ pure/trunk/test/test004.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,52 @@
+
+// Local function with environment test.
+
+foo x = bar with bar = x end;
+foo2 x = bar x with bar 99 = bar (x+1) end;
+foo3 x = bar with bar y = bar (y+1) if y==x end;
+
+foo 99;
+foo2 99; foo2 98;
+foo3 99; foo3 99 98; foo3 99 99;
+
+// Tail recursion.
+
+loop = loop;
+
+// If LLVM supports proper tail calls on your platform, the following should
+// loop forever.
+//loop;
+
+// Tail recursion in a local function.
+
+count n = ct n with
+ ct n::int = n if n<=0;
+ = ct (n-1) otherwise;
+ end;
+
+// This should always work.
+count 100;
+// If proper tail calls are supported, this should work, too, no matter what
+// your stack size is.
+//count 10000000;
+
+// Tail recursion in a global function.
+
+count2 n::int = n if n<=0;
+ = count2 (n-1) otherwise;
+
+// This should always work.
+count2 100;
+// Again, this should work if proper tail calls are supported, no matter what
+// your stack size is.
+//count2 10000000;
+
+// Trivial tail-recursive local function which passes an environment to
+// another local function. Note that the callee can never be tail-called in
+// such a situation because it needs the extra environment parameter which is
+// allocated on the caller's stack in the current implementation.
+
+test x::int = t x
+with t n::int = t (-n) if n<0; = u (n+2) with u _ = n+1 end end;
+
+test 98; test (-97);
Copied: pure/trunk/test/test005.log (from rev 88, pure/trunk/test/test5.log)
===================================================================
--- pure/trunk/test/test005.log (rev 0)
+++ pure/trunk/test/test005.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,13 @@
+fact 0 = 1;
+fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
+{
+ rule #0: fact 0 = 1
+ rule #1: fact n = n*fact (n-1)
+ state 0: #0 #1
+ <var> state 1
+ 0::int state 2
+ state 1: #1
+ state 2: #0 #1
+}
+fact 4;
+24
Copied: pure/trunk/test/test005.pure (from rev 88, pure/trunk/test/test5.pure)
===================================================================
--- pure/trunk/test/test005.pure (rev 0)
+++ pure/trunk/test/test005.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,4 @@
+fact 0 = 1;
+fact n = n * fact (n-1);
+fact 4;
+
Copied: pure/trunk/test/test006.log (from rev 88, pure/trunk/test/test6.log)
===================================================================
--- pure/trunk/test/test006.log (rev 0)
+++ pure/trunk/test/test006.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,11 @@
+fact n/*0:1*/ = 1 if n/*0:1*/==0;
+fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
+{
+ rule #0: fact n = 1 if n==0
+ rule #1: fact n = n*fact (n-1)
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+fact 4;
+24
Copied: pure/trunk/test/test006.pure (from rev 88, pure/trunk/test/test6.pure)
===================================================================
--- pure/trunk/test/test006.pure (rev 0)
+++ pure/trunk/test/test006.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,3 @@
+fact n = 1 if n==0;
+ = n * fact (n-1) otherwise;
+fact 4;
Copied: pure/trunk/test/test007.log (from rev 88, pure/trunk/test/test7.log)
===================================================================
--- pure/trunk/test/test007.log (rev 0)
+++ pure/trunk/test/test007.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,19 @@
+{
+ rule #0: y = \a -> \b -> a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+let y = \a/*0:*/ -> \b/*0:*/ -> a/*1:*/+b/*0:*/ {
+ rule #0: b = a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} {
+ rule #0: a = \b -> a+b
+ state 0: #0
+ <var> state 1
+ state 1: #0
+};
+y 1 5;
+6
Copied: pure/trunk/test/test007.pure (from rev 88, pure/trunk/test/test7.pure)
===================================================================
--- pure/trunk/test/test007.pure (rev 0)
+++ pure/trunk/test/test007.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,2 @@
+let y = (\a b -> a+b);
+y 1 5;
Copied: pure/trunk/test/test008.log (from rev 88, pure/trunk/test/test8.log)
===================================================================
--- pure/trunk/test/test008.log (rev 0)
+++ pure/trunk/test/test008.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,36 @@
+Binomial n/*0:01*/ k/*0:1*/ = Binomial n/*0:01*/ (n/*0:01*/-k/*0:1*/) if n/*0:01*/-k/*0:1*/<k/*0:1*/;
+Binomial n/*0:01*/ 0L = 1L;
+Binomial n/*0:01*/ 0 = 1;
+Binomial n/*0:01*/ 1L = n/*0:01*/;
+Binomial n/*0:01*/ 1 = n/*0:01*/;
+Binomial n/*0:01*/ k/*0:1*/ = Binomial nm2/*0:*/ (k/*1:1*/-2)+2*Binomial nm2/*0:*/ (k/*1:1*/-1)+Binomial nm2/*0:*/ k/*1:1*/ when nm2/*0:*/ = n/*0:01*/-2 {
+ rule #0: nm2 = n-2
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+{
+ rule #0: Binomial n k = Binomial n (n-k) if n-k<k
+ rule #1: Binomial n 0L = 1L
+ rule #2: Binomial n 0 = 1
+ rule #3: Binomial n 1L = n
+ rule #4: Binomial n 1 = n
+ rule #5: Binomial n k = Binomial nm2 (k-2)+2*Binomial nm2 (k-1)+Binomial nm2 k when nm2 = n-2 end
+ state 0: #0 #1 #2 #3 #4 #5
+ <var> state 1
+ state 1: #0 #1 #2 #3 #4 #5
+ <var> state 2
+ 0::int state 3
+ 1::int state 4
+ 0L::bigint state 5
+ 1L::bigint state 6
+ state 2: #0 #5
+ state 3: #0 #2 #5
+ state 4: #0 #4 #5
+ state 5: #0 #1 #5
+ state 6: #0 #3 #5
+}
+Binomial 5 2;
+10
+Binomial 5L 2L;
+10L
Copied: pure/trunk/test/test008.pure (from rev 88, pure/trunk/test/test8.pure)
===================================================================
--- pure/trunk/test/test008.pure (rev 0)
+++ pure/trunk/test/test008.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,13 @@
+Binomial n k = Binomial n (n-k) if n-k < k;
+Binomial n 0L = 1L;
+Binomial n 0 = 1;
+Binomial n 1L = n;
+Binomial n 1 = n;
+Binomial n k =
+ Binomial nm2 (k-2) +
+ 2 * Binomial nm2 (k-1) +
+ Binomial nm2 k
+ when nm2 = n-2 end;
+
+Binomial 5 2;
+Binomial 5L 2L;
Copied: pure/trunk/test/test009.log (from rev 88, pure/trunk/test/test9.log)
===================================================================
--- pure/trunk/test/test009.log (rev 0)
+++ pure/trunk/test/test009.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,108 @@
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+{
+ rule #0: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ rule #1: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+}
+warning: rule never reduced: fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
+ rule #0: a,b = fibs n
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
+ rule #0: a,b = fibs (n-1)
+ state 0: #0
+ <app> state 1
+ state 1: #0
+ <app> state 2
+ state 2: #0
+ , state 3
+ state 3: #0
+ <var> state 4
+ state 4: #0
+ <var> state 5
+ state 5: #0
+} end {
+ rule #0: fibs n = 0,1 if n<=0
+ rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
+ state 0: #0 #1
+ <var> state 1
+ state 1: #0 #1
+} end;
+map fib2 (1..10);
+[1,1,2,3,5,8,13,21,34,55]
Copied: pure/trunk/test/test009.pure (from rev 88, pure/trunk/test/test9.pure)
===================================================================
--- pure/trunk/test/test009.pure (rev 0)
+++ pure/trunk/test/test009.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,11 @@
+fib2 n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+fib2 n = a when a, b = fibs n end
+ with fibs n = 0, 1 if n<=0;
+ = b, a+b when a, b = fibs (n-1) end
+ otherwise;
+ end;
+map fib2 (1..10);
Copied: pure/trunk/test/test010.log (from rev 107, pure/trunk/test/test10.log)
===================================================================
--- pure/trunk/test/test010.log (rev 0)
+++ pure/trunk/test/test010.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,3 @@
+\x -> x!0==[0,1,0,0];
+eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
+1
Copied: pure/trunk/test/test010.pure (from rev 107, pure/trunk/test/test10.pure)
===================================================================
--- pure/trunk/test/test010.pure (rev 0)
+++ pure/trunk/test/test010.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -0,0 +1,2 @@
+
+eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
Deleted: pure/trunk/test/test1.log
===================================================================
--- pure/trunk/test/test1.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test1.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,194 +0,0 @@
-square x/*0:1*/ = x/*0:1*/*x/*0:1*/;
-{
- rule #0: square x = x*x
- state 0: #0
- <var> state 1
- state 1: #0
-}
-square 5;
-25
-fact1 n/*0:1*/ = n/*0:1*/*fact1 (n/*0:1*/-1) if n/*0:1*/>0;
-fact1 n/*0:1*/ = 1;
-{
- rule #0: fact1 n = n*fact1 (n-1) if n>0
- rule #1: fact1 n = 1
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-}
-{
- rule #0: x = fact1 10
- state 0: #0
- <var> state 1
- state 1: #0
-}
-let x = fact1 10;
-x;
-3628800
-fact2 n/*0:1*/ = case n/*0:1*/ of n/*0:*/ = n/*0:*/*fact2 (n/*0:*/-1) if n/*0:*/>0; n/*0:*/ = 1 {
- rule #0: n = n*fact2 (n-1) if n>0
- rule #1: n = 1
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-fact3 n/*0:1*/ = case n/*0:1*/ of 0 = 1; n/*0:*/ = n/*0:*/*fact3 (n/*0:*/-1) if n/*0:*/>0 {
- rule #0: 0 = 1
- rule #1: n = n*fact3 (n-1) if n>0
- state 0: #0 #1
- <var> state 1
- 0::int state 2
- state 1: #1
- state 2: #0 #1
-} end;
-fact4 n/*0:1*/ = if n/*0:1*/>0 then n/*0:1*/*fact4 (n/*0:1*/-1) else 1;
-fact5 = \n/*0:*/ -> if n/*0:*/>0 then n/*0:*/*fact5 (n/*0:*/-1) else 1 {
- rule #0: n = if n>0 then n*fact5 (n-1) else 1
- state 0: #0
- <var> state 1
- state 1: #0
-};
-{
- rule #0: fact2 n = case n of n = n*fact2 (n-1) if n>0; n = 1 end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: fact3 n = case n of 0 = 1; n = n*fact3 (n-1) if n>0 end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: fact4 n = if n>0 then n*fact4 (n-1) else 1
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: fact5 = \n -> if n>0 then n*fact5 (n-1) else 1
- state 0: #0
-}
-fact2 10;
-3628800
-fact3 10;
-3628800
-fact4 10;
-3628800
-fact5 10;
-3628800
-fact n/*0:1*/::int = fact (bigint n/*0:1*/);
-fact n/*0:1*/::bigint = n/*0:1*/*fact (n/*0:1*/-1) if n/*0:1*/>0;
-fact n/*0:1*/::bigint = 1;
-{
- rule #0: fact n::int = fact (bigint n)
- rule #1: fact n::bigint = n*fact (n-1) if n>0
- rule #2: fact n::bigint = 1
- state 0: #0 #1 #2
- <var>::int state 1
- <var>::bigint state 2
- state 1: #0
- state 2: #1 #2
-}
-fact 50;
-30414093201713378043612608166064768844377641568960512000000000000L
-fib1 0 = 0;
-fib1 1 = 1;
-fib1 n/*0:1*/ = fib1 (n/*0:1*/-2)+fib1 (n/*0:1*/-1) if n/*0:1*/>1;
-fib2 n/*0:1*/ = case fibs/*0*/ n/*0:1*/ of a/*0:01*/,b/*0:1*/ = a/*0:01*/ {
- rule #0: a,b = a
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = case fibs/*1*/ (n/*0:1*/-1) of a/*0:01*/,b/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ {
- rule #0: a,b = b,a+b
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = case fibs (n-1) of a,b = b,a+b end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-fib3 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
- rule #0: a,b = fibs n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
- rule #0: a,b = fibs (n-1)
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-{
- rule #0: fib1 0 = 0
- rule #1: fib1 1 = 1
- rule #2: fib1 n = fib1 (n-2)+fib1 (n-1) if n>1
- state 0: #0 #1 #2
- <var> state 1
- 0::int state 2
- 1::int state 3
- state 1: #2
- state 2: #0 #2
- state 3: #1 #2
-}
-{
- rule #0: fib2 n = case fibs n of a,b = a end with fibs n = 0,1 if n<=0; fibs n = case fibs (n-1) of a,b = b,a+b end end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: fib3 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-map fib1 (1..10);
-[1,1,2,3,5,8,13,21,34,55]
-map fib2 (1..10);
-[1,1,2,3,5,8,13,21,34,55]
-map fib3 (1..10);
-[1,1,2,3,5,8,13,21,34,55]
Deleted: pure/trunk/test/test1.pure
===================================================================
--- pure/trunk/test/test1.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test1.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,82 +0,0 @@
-
-// A simple script with some function and variable definitions.
-// This is used to test the guts of the interpreter.
-
-square x = x*x;
-
-/* a multiline
- comment */
-
-square 5;
-
-// Factorial, with guarded rules.
-
-fact1 n = n*fact1 (n-1) if n>0;
- = 1 otherwise;
-
-let x = fact1 10; x;
-
-// Factorial, using case.
-
-fact2 n = case n of
- n = n*fact2 (n-1) if n>0;
- = 1 otherwise;
- end;
-
-// Factorial, yet another one.
-
-fact3 n = case n of
- 0 = 1;
- n = n*fact3 (n-1) if n>0;
- end;
-
-// Factorial, with if-then-else.
-
-fact4 n = if n>0 then n*fact4 (n-1) else 1;
-
-// Factorial, with lambda ("pointless style").
-
-fact5 = \n -> if n>0 then n*fact5 (n-1) else 1;
-
-fact2 10;
-fact3 10;
-fact4 10;
-fact5 10;
-
-// Factorial, using bigints.
-
-fact n::int = fact (bigint n);
-fact n::bigint = n*fact (n-1) if n>0;
- = 1 otherwise;
-
-fact 50;
-
-// Fibonacci function, naive O(fib n) implementation.
-
-fib1 0 = 0;
-fib1 1 = 1;
-fib1 n = fib1 (n-2) + fib1 (n-1) if n>1;
-
-// Fibonacci function, O(n) implementation.
-
-fib2 n = case fibs n of
- a, b = a;
- end
- with
- fibs n = 0, 1 if n<=0;
- = case fibs (n-1) of
- a, b = b, a+b;
- end otherwise;
- end;
-
-// Fibonacci function, another O(N) implementation.
-
-fib3 n = a when a, b = fibs n end
- with fibs n = 0, 1 if n<=0;
- = b, a+b when a, b = fibs (n-1) end
- otherwise;
- end;
-
-map fib1 (1..10);
-map fib2 (1..10);
-map fib3 (1..10);
Deleted: pure/trunk/test/test10.log
===================================================================
--- pure/trunk/test/test10.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test10.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,3 +0,0 @@
-\x -> x!0==[0,1,0,0];
-eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
-1
Deleted: pure/trunk/test/test10.pure
===================================================================
--- pure/trunk/test/test10.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test10.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,2 +0,0 @@
-
-eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
Deleted: pure/trunk/test/test2.log
===================================================================
--- pure/trunk/test/test2.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test2.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,63 +0,0 @@
-fib n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
- rule #0: a,b = fibs n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
- rule #0: a,b = fibs (n-1)
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ (0L,1L) n/*0:1*/ {
- rule #0: a,b = fibs (0L,1L) n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = a/*0:0101*/,b/*0:011*/ if n/*0:1*/<=0; fibs (a/*0:0101*/,b/*0:011*/) n/*0:1*/ = fibs/*1*/ (b/*0:011*/,a/*0:0101*/+b/*0:011*/) (n/*0:1*/-1) {
- rule #0: fibs (a,b) n = a,b if n<=0
- rule #1: fibs (a,b) n = fibs (b,a+b) (n-1)
- state 0: #0 #1
- <app> state 1
- state 1: #0 #1
- <app> state 2
- state 2: #0 #1
- , state 3
- state 3: #0 #1
- <var> state 4
- state 4: #0 #1
- <var> state 5
- state 5: #0 #1
- <var> state 6
- state 6: #0 #1
-} end;
Deleted: pure/trunk/test/test2.pure
===================================================================
--- pure/trunk/test/test2.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test2.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,12 +0,0 @@
-fib n = a when a, b = fibs n end
- with fibs n = 0, 1 if n<=0;
- = b, a+b when a, b = fibs (n-1) end
- otherwise;
- end;
-
-// tail-recursive version, using bigints
-
-fib2 n = a when a, b = fibs (0L, 1L) n end
- with fibs (a, b) n = a, b if n<=0;
- = fibs (b, a+b) (n-1) otherwise;
- end;
Deleted: pure/trunk/test/test3.log
===================================================================
--- pure/trunk/test/test3.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test3.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,20 +0,0 @@
-fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0;
-fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when m/*0:*/ = n/*0:1*/-1; a/*0:01*/,b/*0:1*/ = fibs m/*0:*/ {
- rule #0: a,b = fibs m
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} {
- rule #0: m = n-1
- state 0: #0
- <var> state 1
- state 1: #0
-} end;
Deleted: pure/trunk/test/test3.pure
===================================================================
--- pure/trunk/test/test3.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test3.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,3 +0,0 @@
-fibs n = 0, 1 if n<=0;
- = b, a+b when m = n-1; a, b = fibs m end
- otherwise;
Deleted: pure/trunk/test/test4.log
===================================================================
--- pure/trunk/test/test4.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test4.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,99 +0,0 @@
-foo x/*0:1*/ = bar/*0*/ with bar = x/*1:1*/ {
- rule #0: bar = x
- state 0: #0
-} end;
-foo2 x/*0:1*/ = bar/*0*/ x/*0:1*/ with bar 99 = bar/*1*/ (x/*1:1*/+1) {
- rule #0: bar 99 = bar (x+1)
- state 0: #0
- 99::int state 1
- state 1: #0
-} end;
-foo3 x/*0:1*/ = bar/*0*/ with bar y/*0:1*/ = bar/*1*/ (y/*0:1*/+1) if y/*0:1*/==x/*1:1*/ {
- rule #0: bar y = bar (y+1) if y==x
- state 0: #0
- <var> state 1
- state 1: #0
-} end;
-{
- rule #0: foo x = bar with bar = x end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: foo2 x = bar x with bar 99 = bar (x+1) end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-{
- rule #0: foo3 x = bar with bar y = bar (y+1) if y==x end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-foo 99;
-99
-foo2 99;
-bar 100
-foo2 98;
-bar 98
-foo3 99;
-bar
-foo3 99 98;
-bar 98
-foo3 99 99;
-bar 100
-loop = loop;
-count n/*0:1*/ = ct/*0*/ n/*0:1*/ with ct n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0; ct n/*0:1*/::int = ct/*1*/ (n/*0:1*/-1) {
- rule #0: ct n::int = n if n<=0
- rule #1: ct n::int = ct (n-1)
- state 0: #0 #1
- <var>::int state 1
- state 1: #0 #1
-} end;
-{
- rule #0: loop = loop
- state 0: #0
-}
-{
- rule #0: count n = ct n with ct n::int = n if n<=0; ct n::int = ct (n-1) end
- state 0: #0
- <var> state 1
- state 1: #0
-}
-count 100;
-0
-count2 n/*0:1*/::int = n/*0:1*/ if n/*0:1*/<=0;
-count2 n/*0:1*/::int = count2 (n/*0:1*/-1);
-{
- rule #0: count2 n::int = n if n<=0
- rule #1: count2 n::int = count2 (n-1)
- state 0: #0 #1
- <var>::int state 1
- state 1: #0 #1
-}
-count2 100;
-0
-test x/*0:1*/::int = t/*0*/ x/*0:1*/ with t n/*0:1*/::int = t/*1*/ (-n/*0:1*/) if n/*0:1*/<0; t n/*0:1*/::int = u/*0*/ (n/*0:1*/+2) with u _/*0:1*/ = n/*1:1*/+1 {
- rule #0: u _ = n+1
- state 0: #0
- <var> state 1
- state 1: #0
-} end {
- rule #0: t n::int = t (-n) if n<0
- rule #1: t n::int = u (n+2) with u _ = n+1 end
- state 0: #0 #1
- <var>::int state 1
- state 1: #0 #1
-} end;
-{
- rule #0: test x::int = t x with t n::int = t (-n) if n<0; t n::int = u (n+2) with u _ = n+1 end end
- state 0: #0
- <var>::int state 1
- state 1: #0
-}
-test 98;
-99
-test (-97);
-98
Deleted: pure/trunk/test/test4.pure
===================================================================
--- pure/trunk/test/test4.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test4.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,52 +0,0 @@
-
-// Local function with environment test.
-
-foo x = bar with bar = x end;
-foo2 x = bar x with bar 99 = bar (x+1) end;
-foo3 x = bar with bar y = bar (y+1) if y==x end;
-
-foo 99;
-foo2 99; foo2 98;
-foo3 99; foo3 99 98; foo3 99 99;
-
-// Tail recursion.
-
-loop = loop;
-
-// If LLVM supports proper tail calls on your platform, the following should
-// loop forever.
-//loop;
-
-// Tail recursion in a local function.
-
-count n = ct n with
- ct n::int = n if n<=0;
- = ct (n-1) otherwise;
- end;
-
-// This should always work.
-count 100;
-// If proper tail calls are supported, this should work, too, no matter what
-// your stack size is.
-//count 10000000;
-
-// Tail recursion in a global function.
-
-count2 n::int = n if n<=0;
- = count2 (n-1) otherwise;
-
-// This should always work.
-count2 100;
-// Again, this should work if proper tail calls are supported, no matter what
-// your stack size is.
-//count2 10000000;
-
-// Trivial tail-recursive local function which passes an environment to
-// another local function. Note that the callee can never be tail-called in
-// such a situation because it needs the extra environment parameter which is
-// allocated on the caller's stack in the current implementation.
-
-test x::int = t x
-with t n::int = t (-n) if n<0; = u (n+2) with u _ = n+1 end end;
-
-test 98; test (-97);
Deleted: pure/trunk/test/test5.log
===================================================================
--- pure/trunk/test/test5.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test5.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,13 +0,0 @@
-fact 0 = 1;
-fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
-{
- rule #0: fact 0 = 1
- rule #1: fact n = n*fact (n-1)
- state 0: #0 #1
- <var> state 1
- 0::int state 2
- state 1: #1
- state 2: #0 #1
-}
-fact 4;
-24
Deleted: pure/trunk/test/test5.pure
===================================================================
--- pure/trunk/test/test5.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test5.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,4 +0,0 @@
-fact 0 = 1;
-fact n = n * fact (n-1);
-fact 4;
-
Deleted: pure/trunk/test/test6.log
===================================================================
--- pure/trunk/test/test6.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test6.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,11 +0,0 @@
-fact n/*0:1*/ = 1 if n/*0:1*/==0;
-fact n/*0:1*/ = n/*0:1*/*fact (n/*0:1*/-1);
-{
- rule #0: fact n = 1 if n==0
- rule #1: fact n = n*fact (n-1)
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-}
-fact 4;
-24
Deleted: pure/trunk/test/test6.pure
===================================================================
--- pure/trunk/test/test6.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test6.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,3 +0,0 @@
-fact n = 1 if n==0;
- = n * fact (n-1) otherwise;
-fact 4;
Deleted: pure/trunk/test/test7.log
===================================================================
--- pure/trunk/test/test7.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test7.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,19 +0,0 @@
-{
- rule #0: y = \a -> \b -> a+b
- state 0: #0
- <var> state 1
- state 1: #0
-}
-let y = \a/*0:*/ -> \b/*0:*/ -> a/*1:*/+b/*0:*/ {
- rule #0: b = a+b
- state 0: #0
- <var> state 1
- state 1: #0
-} {
- rule #0: a = \b -> a+b
- state 0: #0
- <var> state 1
- state 1: #0
-};
-y 1 5;
-6
Deleted: pure/trunk/test/test7.pure
===================================================================
--- pure/trunk/test/test7.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test7.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,2 +0,0 @@
-let y = (\a b -> a+b);
-y 1 5;
Deleted: pure/trunk/test/test8.log
===================================================================
--- pure/trunk/test/test8.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test8.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,36 +0,0 @@
-Binomial n/*0:01*/ k/*0:1*/ = Binomial n/*0:01*/ (n/*0:01*/-k/*0:1*/) if n/*0:01*/-k/*0:1*/<k/*0:1*/;
-Binomial n/*0:01*/ 0L = 1L;
-Binomial n/*0:01*/ 0 = 1;
-Binomial n/*0:01*/ 1L = n/*0:01*/;
-Binomial n/*0:01*/ 1 = n/*0:01*/;
-Binomial n/*0:01*/ k/*0:1*/ = Binomial nm2/*0:*/ (k/*1:1*/-2)+2*Binomial nm2/*0:*/ (k/*1:1*/-1)+Binomial nm2/*0:*/ k/*1:1*/ when nm2/*0:*/ = n/*0:01*/-2 {
- rule #0: nm2 = n-2
- state 0: #0
- <var> state 1
- state 1: #0
-} end;
-{
- rule #0: Binomial n k = Binomial n (n-k) if n-k<k
- rule #1: Binomial n 0L = 1L
- rule #2: Binomial n 0 = 1
- rule #3: Binomial n 1L = n
- rule #4: Binomial n 1 = n
- rule #5: Binomial n k = Binomial nm2 (k-2)+2*Binomial nm2 (k-1)+Binomial nm2 k when nm2 = n-2 end
- state 0: #0 #1 #2 #3 #4 #5
- <var> state 1
- state 1: #0 #1 #2 #3 #4 #5
- <var> state 2
- 0::int state 3
- 1::int state 4
- 0L::bigint state 5
- 1L::bigint state 6
- state 2: #0 #5
- state 3: #0 #2 #5
- state 4: #0 #4 #5
- state 5: #0 #1 #5
- state 6: #0 #3 #5
-}
-Binomial 5 2;
-10
-Binomial 5L 2L;
-10L
Deleted: pure/trunk/test/test8.pure
===================================================================
--- pure/trunk/test/test8.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test8.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,13 +0,0 @@
-Binomial n k = Binomial n (n-k) if n-k < k;
-Binomial n 0L = 1L;
-Binomial n 0 = 1;
-Binomial n 1L = n;
-Binomial n 1 = n;
-Binomial n k =
- Binomial nm2 (k-2) +
- 2 * Binomial nm2 (k-1) +
- Binomial nm2 k
- when nm2 = n-2 end;
-
-Binomial 5 2;
-Binomial 5L 2L;
Deleted: pure/trunk/test/test9.log
===================================================================
--- pure/trunk/test/test9.log 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test9.log 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,108 +0,0 @@
-fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
- rule #0: a,b = fibs n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
- rule #0: a,b = fibs (n-1)
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
- rule #0: a,b = fibs n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
- rule #0: a,b = fibs (n-1)
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-{
- rule #0: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
- rule #1: fib2 n = a when a,b = fibs n end with fibs n = 0,1 if n<=0; fibs n = b,a+b when a,b = fibs (n-1) end end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-}
-warning: rule never reduced: fib2 n/*0:1*/ = a/*0:01*/ when a/*0:01*/,b/*0:1*/ = fibs/*0*/ n/*0:1*/ {
- rule #0: a,b = fibs n
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end with fibs n/*0:1*/ = 0,1 if n/*0:1*/<=0; fibs n/*0:1*/ = b/*0:1*/,a/*0:01*/+b/*0:1*/ when a/*0:01*/,b/*0:1*/ = fibs/*1*/ (n/*0:1*/-1) {
- rule #0: a,b = fibs (n-1)
- state 0: #0
- <app> state 1
- state 1: #0
- <app> state 2
- state 2: #0
- , state 3
- state 3: #0
- <var> state 4
- state 4: #0
- <var> state 5
- state 5: #0
-} end {
- rule #0: fibs n = 0,1 if n<=0
- rule #1: fibs n = b,a+b when a,b = fibs (n-1) end
- state 0: #0 #1
- <var> state 1
- state 1: #0 #1
-} end;
-map fib2 (1..10);
-[1,1,2,3,5,8,13,21,34,55]
Deleted: pure/trunk/test/test9.pure
===================================================================
--- pure/trunk/test/test9.pure 2008-05-23 01:15:11 UTC (rev 107)
+++ pure/trunk/test/test9.pure 2008-05-23 01:24:21 UTC (rev 108)
@@ -1,11 +0,0 @@
-fib2 n = a when a, b = fibs n end
- with fibs n = 0, 1 if n<=0;
- = b, a+b when a, b = fibs (n-1) end
- otherwise;
- end;
-fib2 n = a when a, b = fibs n end
- with fibs n = 0, 1 if n<=0;
- = b, a+b when a, b = fibs (n-1) end
- otherwise;
- end;
-map fib2 (1..10);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-06-25 23:02:17
|
Revision: 312
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=312&view=rev
Author: agraef
Date: 2008-06-25 16:02:21 -0700 (Wed, 25 Jun 2008)
Log Message:
-----------
Add regression test for constant definitions.
Added Paths:
-----------
pure/trunk/test/test013.log
pure/trunk/test/test013.pure
Added: pure/trunk/test/test013.log
===================================================================
--- pure/trunk/test/test013.log (rev 0)
+++ pure/trunk/test/test013.log 2008-06-25 23:02:21 UTC (rev 312)
@@ -0,0 +1,10 @@
+def pi = 4*atan 1.0;
+foo x/*0:1*/ = 3.14159265358979*x/*0:1*/;
+{
+ rule #0: foo x = 3.14159265358979*x
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+foo 2;
+6.28318530717959
Added: pure/trunk/test/test013.pure
===================================================================
--- pure/trunk/test/test013.pure (rev 0)
+++ pure/trunk/test/test013.pure 2008-06-25 23:02:21 UTC (rev 312)
@@ -0,0 +1,9 @@
+
+// constant definition example
+
+extern double atan(double);
+def pi = 4*atan 1.0;
+
+foo x = pi*x;
+
+foo 2;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-05-23 05:22:55
|
Revision: 111
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=111&view=rev
Author: agraef
Date: 2008-05-22 22:23:01 -0700 (Thu, 22 May 2008)
Log Message:
-----------
Fix premature freeing of eval result. Add regression test.
Modified Paths:
--------------
pure/trunk/test/test010.log
pure/trunk/test/test010.pure
Modified: pure/trunk/test/test010.log
===================================================================
--- pure/trunk/test/test010.log 2008-05-23 05:18:37 UTC (rev 110)
+++ pure/trunk/test/test010.log 2008-05-23 05:23:01 UTC (rev 111)
@@ -1,3 +1,8 @@
\x -> x!0==[0,1,0,0];
eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
1
+1.2;
+-4;
+that;
+map eval ["1.2","-4","that"];
+[1.2,-4,that]
Modified: pure/trunk/test/test010.pure
===================================================================
--- pure/trunk/test/test010.pure 2008-05-23 05:18:37 UTC (rev 110)
+++ pure/trunk/test/test010.pure 2008-05-23 05:23:01 UTC (rev 111)
@@ -1,2 +1,3 @@
eval "(\\x -> (x!0) == [0,1,0,0])" [[0,1,0,0],[1,1,2]];
+map (eval) ["1.2","-4","that"];
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ag...@us...> - 2008-07-02 08:08:26
|
Revision: 366
http://pure-lang.svn.sourceforge.net/pure-lang/?rev=366&view=rev
Author: agraef
Date: 2008-07-02 01:08:35 -0700 (Wed, 02 Jul 2008)
Log Message:
-----------
Add rational tests.
Added Paths:
-----------
pure/trunk/test/test014.log
pure/trunk/test/test014.pure
Added: pure/trunk/test/test014.log
===================================================================
--- pure/trunk/test/test014.log (rev 0)
+++ pure/trunk/test/test014.log 2008-07-02 08:08:35 UTC (rev 366)
@@ -0,0 +1,6313 @@
+def inf = 1e+307*1e+307;
+def nan = inf-inf;
+abs x/*0:1*/::int = if x/*0:1*/>=0 then x/*0:1*/ else -x/*0:1*/;
+abs x/*0:1*/::bigint = if x/*0:1*/>=0 then x/*0:1*/ else -x/*0:1*/;
+abs x/*0:1*/::double = if x/*0:1*/>=0 then x/*0:1*/ else -x/*0:1*/;
+sgn x/*0:1*/::int = if x/*0:1*/>0 then 1 else if x/*0:1*/<0 then -1 else 0;
+sgn x/*0:1*/::bigint = if x/*0:1*/>0 then 1 else if x/*0:1*/<0 then -1 else 0;
+sgn x/*0:1*/::double = if x/*0:1*/>0 then 1 else if x/*0:1*/<0 then -1 else 0;
+min x/*0:01*/ y/*0:1*/ = if x/*0:01*/<=y/*0:1*/ then x/*0:01*/ else y/*0:1*/;
+max x/*0:01*/ y/*0:1*/ = if x/*0:01*/>=y/*0:1*/ then x/*0:01*/ else y/*0:1*/;
+succ x/*0:1*/ = x/*0:1*/+1;
+pred x/*0:1*/ = x/*0:1*/-1;
+floor x/*0:1*/::int = x/*0:1*/;
+floor x/*0:1*/::bigint = x/*0:1*/;
+ceil x/*0:1*/::int = x/*0:1*/;
+ceil x/*0:1*/::bigint = x/*0:1*/;
+round x/*0:1*/::int = x/*0:1*/;
+round x/*0:1*/::bigint = x/*0:1*/;
+trunc x/*0:1*/::int = x/*0:1*/;
+trunc x/*0:1*/::bigint = x/*0:1*/;
+frac x/*0:1*/::int = x/*0:1*/-trunc x/*0:1*/;
+frac x/*0:1*/::bigint = x/*0:1*/-trunc x/*0:1*/;
+frac x/*0:1*/::double = x/*0:1*/-trunc x/*0:1*/;
+sqrt x/*0:1*/::double = c_sqrt x/*0:1*/ if x/*0:1*/>=0;
+sqrt x/*0:1*/::int = sqrt (double x/*0:1*/);
+sqrt x/*0:1*/::bigint = sqrt (double x/*0:1*/);
+ln x/*0:1*/::double = c_log x/*0:1*/ if x/*0:1*/>=0.0;
+log x/*0:1*/::double = c_log x/*0:1*//c_log 10.0 if x/*0:1*/>=0.0;
+exp x/*0:1*/::int = exp (double x/*0:1*/);
+exp x/*0:1*/::bigint = exp (double x/*0:1*/);
+ln x/*0:1*/::int = ln (double x/*0:1*/);
+ln x/*0:1*/::bigint = ln (double x/*0:1*/);
+log x/*0:1*/::int = log (double x/*0:1*/);
+log x/*0:1*/::bigint = log (double x/*0:1*/);
+{
+ rule #0: max x y = if x>=y then x else y
+ state 0: #0
+ <var> state 1
+ state 1: #0
+ <var> state 2
+ state 2: #0
+}
+{
+ rule #0: abs x::int = if x>=0 then x else -x
+ rule #1: abs x::bigint = if x>=0 then x else -x
+ rule #2: abs x::double = if x>=0 then x else -x
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #0
+ state 2: #1
+ state 3: #2
+}
+{
+ rule #0: sgn x::int = if x>0 then 1 else if x<0 then -1 else 0
+ rule #1: sgn x::bigint = if x>0 then 1 else if x<0 then -1 else 0
+ rule #2: sgn x::double = if x>0 then 1 else if x<0 then -1 else 0
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #0
+ state 2: #1
+ state 3: #2
+}
+{
+ rule #0: min x y = if x<=y then x else y
+ state 0: #0
+ <var> state 1
+ state 1: #0
+ <var> state 2
+ state 2: #0
+}
+{
+ rule #0: succ x = x+1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: pred x = x-1
+ state 0: #0
+ <var> state 1
+ state 1: #0
+}
+{
+ rule #0: floor x::int = x
+ rule #1: floor x::bigint = x
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: ceil x::int = x
+ rule #1: ceil x::bigint = x
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: round x::int = x
+ rule #1: round x::bigint = x
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: trunc x::int = x
+ rule #1: trunc x::bigint = x
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: frac x::int = x-trunc x
+ rule #1: frac x::bigint = x-trunc x
+ rule #2: frac x::double = x-trunc x
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #0
+ state 2: #1
+ state 3: #2
+}
+{
+ rule #0: sqrt x::double = c_sqrt x if x>=0
+ rule #1: sqrt x::int = sqrt (double x)
+ rule #2: sqrt x::bigint = sqrt (double x)
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #1
+ state 2: #2
+ state 3: #0
+}
+{
+ rule #0: exp x::int = exp (double x)
+ rule #1: exp x::bigint = exp (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: ln x::double = c_log x if x>=0.0
+ rule #1: ln x::int = ln (double x)
+ rule #2: ln x::bigint = ln (double x)
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #1
+ state 2: #2
+ state 3: #0
+}
+{
+ rule #0: log x::double = c_log x/c_log 10.0 if x>=0.0
+ rule #1: log x::int = log (double x)
+ rule #2: log x::bigint = log (double x)
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #1
+ state 2: #2
+ state 3: #0
+}
+def e = exp 1.0;
+sin x/*0:1*/::int = sin (double x/*0:1*/);
+sin x/*0:1*/::bigint = sin (double x/*0:1*/);
+cos x/*0:1*/::int = cos (double x/*0:1*/);
+cos x/*0:1*/::bigint = cos (double x/*0:1*/);
+tan x/*0:1*/::int = tan (double x/*0:1*/);
+tan x/*0:1*/::bigint = tan (double x/*0:1*/);
+asin x/*0:1*/::int = asin (double x/*0:1*/);
+asin x/*0:1*/::bigint = asin (double x/*0:1*/);
+acos x/*0:1*/::int = acos (double x/*0:1*/);
+acos x/*0:1*/::bigint = acos (double x/*0:1*/);
+atan x/*0:1*/::int = atan (double x/*0:1*/);
+atan x/*0:1*/::bigint = atan (double x/*0:1*/);
+atan2 x/*0:01*/::int y/*0:1*/::int = atan2 (double x/*0:01*/) (double y/*0:1*/);
+atan2 x/*0:01*/::bigint y/*0:1*/::bigint = atan2 (double x/*0:01*/) (double y/*0:1*/);
+atan2 x/*0:01*/::bigint y/*0:1*/::int = atan2 (double x/*0:01*/) (double y/*0:1*/);
+atan2 x/*0:01*/::int y/*0:1*/::bigint = atan2 (double x/*0:01*/) (double y/*0:1*/);
+atan2 x/*0:01*/::int y/*0:1*/::double = atan2 (double x/*0:01*/) y/*0:1*/;
+atan2 x/*0:01*/::bigint y/*0:1*/::double = atan2 (double x/*0:01*/) y/*0:1*/;
+atan2 x/*0:01*/::double y/*0:1*/::int = atan2 x/*0:01*/ (double y/*0:1*/);
+atan2 x/*0:01*/::double y/*0:1*/::bigint = atan2 x/*0:01*/ (double y/*0:1*/);
+{
+ rule #0: sin x::int = sin (double x)
+ rule #1: sin x::bigint = sin (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: cos x::int = cos (double x)
+ rule #1: cos x::bigint = cos (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: tan x::int = tan (double x)
+ rule #1: tan x::bigint = tan (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: asin x::int = asin (double x)
+ rule #1: asin x::bigint = asin (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: acos x::int = acos (double x)
+ rule #1: acos x::bigint = acos (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: atan x::int = atan (double x)
+ rule #1: atan x::bigint = atan (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: atan2 x::int y::int = atan2 (double x) (double y)
+ rule #1: atan2 x::bigint y::bigint = atan2 (double x) (double y)
+ rule #2: atan2 x::bigint y::int = atan2 (double x) (double y)
+ rule #3: atan2 x::int y::bigint = atan2 (double x) (double y)
+ rule #4: atan2 x::int y::double = atan2 (double x) y
+ rule #5: atan2 x::bigint y::double = atan2 (double x) y
+ rule #6: atan2 x::double y::int = atan2 x (double y)
+ rule #7: atan2 x::double y::bigint = atan2 x (double y)
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7
+ <var>::int state 1
+ <var>::bigint state 5
+ <var>::double state 9
+ state 1: #0 #3 #4
+ <var>::int state 2
+ <var>::bigint state 3
+ <var>::double state 4
+ state 2: #0
+ state 3: #3
+ state 4: #4
+ state 5: #1 #2 #5
+ <var>::int state 6
+ <var>::bigint state 7
+ <var>::double state 8
+ state 6: #2
+ state 7: #1
+ state 8: #5
+ state 9: #6 #7
+ <var>::int state 10
+ <var>::bigint state 11
+ state 10: #6
+ state 11: #7
+}
+def pi = 4.0*atan 1.0;
+acosh x/*0:1*/::double = c_acosh x/*0:1*/ if x/*0:1*/>=1.0;
+atanh x/*0:1*/::double = c_atanh x/*0:1*/ if abs x/*0:1*/<=1.0;
+sinh x/*0:1*/::int = sinh (double x/*0:1*/);
+sinh x/*0:1*/::bigint = sinh (double x/*0:1*/);
+cosh x/*0:1*/::int = cosh (double x/*0:1*/);
+cosh x/*0:1*/::bigint = cosh (double x/*0:1*/);
+tanh x/*0:1*/::int = tanh (double x/*0:1*/);
+tanh x/*0:1*/::bigint = tanh (double x/*0:1*/);
+asinh x/*0:1*/::int = asinh (double x/*0:1*/);
+asinh x/*0:1*/::bigint = asinh (double x/*0:1*/);
+acosh x/*0:1*/::int = acosh (double x/*0:1*/);
+acosh x/*0:1*/::bigint = acosh (double x/*0:1*/);
+atanh x/*0:1*/::int = atanh (double x/*0:1*/);
+atanh x/*0:1*/::bigint = atanh (double x/*0:1*/);
+r/*0:01*/::int<:t/*0:1*/ = -r/*0:01*/<:t/*0:1*/+3.14159265358979 if r/*0:01*/<0;
+r/*0:01*/::bigint<:t/*0:1*/ = -r/*0:01*/<:t/*0:1*/+3.14159265358979 if r/*0:01*/<0;
+r/*0:01*/::double<:t/*0:1*/ = -r/*0:01*/<:t/*0:1*/+3.14159265358979 if r/*0:01*/<0;
+r/*0:01*/<:t/*0:1*/::int = r/*0:01*/<:atan2 (sin t/*0:1*/) (cos t/*0:1*/) if t/*0:1*/<-3.14159265358979||t/*0:1*/>3.14159265358979;
+r/*0:01*/<:t/*0:1*/::bigint = r/*0:01*/<:atan2 (sin t/*0:1*/) (cos t/*0:1*/) if t/*0:1*/<-3.14159265358979||t/*0:1*/>3.14159265358979;
+r/*0:01*/<:t/*0:1*/::double = r/*0:01*/<:atan2 (sin t/*0:1*/) (cos t/*0:1*/) if t/*0:1*/<-3.14159265358979||t/*0:1*/>3.14159265358979;
+r/*0:01*/<:t/*0:1*/::int = r/*0:01*/<:3.14159265358979 if t/*0:1*/==-3.14159265358979;
+r/*0:01*/<:t/*0:1*/::bigint = r/*0:01*/<:3.14159265358979 if t/*0:1*/==-3.14159265358979;
+r/*0:01*/<:t/*0:1*/::double = r/*0:01*/<:3.14159265358979 if t/*0:1*/==-3.14159265358979;
+{
+ rule #0: sinh x::int = sinh (double x)
+ rule #1: sinh x::bigint = sinh (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: cosh x::int = cosh (double x)
+ rule #1: cosh x::bigint = cosh (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: tanh x::int = tanh (double x)
+ rule #1: tanh x::bigint = tanh (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: asinh x::int = asinh (double x)
+ rule #1: asinh x::bigint = asinh (double x)
+ state 0: #0 #1
+ <var>::int state 1
+ <var>::bigint state 2
+ state 1: #0
+ state 2: #1
+}
+{
+ rule #0: acosh x::double = c_acosh x if x>=1.0
+ rule #1: acosh x::int = acosh (double x)
+ rule #2: acosh x::bigint = acosh (double x)
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #1
+ state 2: #2
+ state 3: #0
+}
+{
+ rule #0: atanh x::double = c_atanh x if abs x<=1.0
+ rule #1: atanh x::int = atanh (double x)
+ rule #2: atanh x::bigint = atanh (double x)
+ state 0: #0 #1 #2
+ <var>::int state 1
+ <var>::bigint state 2
+ <var>::double state 3
+ state 1: #1
+ state 2: #2
+ state 3: #0
+}
+{
+ rule #0: r::int<:t = -r<:t+3.14159265358979 if r<0
+ rule #1: r::bigint<:t = -r<:t+3.14159265358979 if r<0
+ rule #2: r::double<:t = -r<:t+3.14159265358979 if r<0
+ rule #3: r<:t::int = r<:atan2 (sin t) (cos t) if t<-3.14159265358979||t>3.14159265358979
+ rule #4: r<:t::bigint = r<:atan2 (sin t) (cos t) if t<-3.14159265358979||t>3.14159265358979
+ rule #5: r<:t::double = r<:atan2 (sin t) (cos t) if t<-3.14159265358979||t>3.14159265358979
+ rule #6: r<:t::int = r<:3.14159265358979 if t==-3.14159265358979
+ rule #7: r<:t::bigint = r<:3.14159265358979 if t==-3.14159265358979
+ rule #8: r<:t::double = r<:3.14159265358979 if t==-3.14159265358979
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8
+ <var> state 1
+ <var>::int state 5
+ <var>::bigint state 10
+ <var>::double state 15
+ state 1: #3 #4 #5 #6 #7 #8
+ <var>::int state 2
+ <var>::bigint state 3
+ <var>::double state 4
+ state 2: #3 #6
+ state 3: #4 #7
+ state 4: #5 #8
+ state 5: #0 #3 #4 #5 #6 #7 #8
+ <var> state 6
+ <var>::int state 7
+ <var>::bigint state 8
+ <var>::double state 9
+ state 6: #0
+ state 7: #0 #3 #6
+ state 8: #0 #4 #7
+ state 9: #0 #5 #8
+ state 10: #1 #3 #4 #5 #6 #7 #8
+ <var> state 11
+ <var>::int state 12
+ <var>::bigint state 13
+ <var>::double state 14
+ state 11: #1
+ state 12: #1 #3 #6
+ state 13: #1 #4 #7
+ state 14: #1 #5 #8
+ state 15: #2 #3 #4 #5 #6 #7 #8
+ <var> state 16
+ <var>::int state 17
+ <var>::bigint state 18
+ <var>::double state 19
+ state 16: #2
+ state 17: #2 #3 #6
+ state 18: #2 #4 #7
+ state 19: #2 #5 #8
+}
+def i = 0+:1;
+complex z@(x/*0:101*/+:y/*0:11*/) = z/*0:1*/;
+complex z@(r/*0:101*/<:t/*0:11*/) = z/*0:1*/;
+complex x/*0:1*/::int = x/*0:1*/+:0;
+complex x/*0:1*/::bigint = x/*0:1*/+:0;
+complex x/*0:1*/::double = x/*0:1*/+:0.0;
+polar (x/*0:101*/+:y/*0:11*/) = sqrt (x/*0:101*/*x/*0:101*/+y/*0:11*/*y/*0:11*/)<:atan2 y/*0:11*/ x/*0:101*/;
+rect (r/*0:101*/<:t/*0:11*/) = r/*0:101*/*cos t/*0:11*/+:r/*0:101*/*sin t/*0:11*/;
+polar x/*0:1*/::int = x/*0:1*/<:0;
+polar x/*0:1*/::bigint = x/*0:1*/<:0;
+polar x/*0:1*/::double = x/*0:1*/<:0.0;
+rect x/*0:1*/::int = x/*0:1*/+:0;
+rect x/*0:1*/::bigint = x/*0:1*/+:0;
+rect x/*0:1*/::double = x/*0:1*/+:0.0;
+cis t/*0:1*/ = rect (1<:t/*0:1*/);
+abs (x/*0:101*/+:y/*0:11*/) = sqrt (x/*0:101*/*x/*0:101*/+y/*0:11*/*y/*0:11*/);
+abs (r/*0:101*/<:t/*0:11*/) = r/*0:101*/;
+arg (x/*0:101*/+:y/*0:11*/) = atan2 y/*0:11*/ x/*0:101*/;
+arg (r/*0:101*/<:t/*0:11*/) = t/*0:11*/;
+arg x/*0:1*/::int = atan2 0 x/*0:1*/;
+arg x/*0:1*/::bigint = atan2 0 x/*0:1*/;
+arg x/*0:1*/::double = atan2 0 x/*0:1*/;
+re (x/*0:101*/+:y/*0:11*/) = x/*0:101*/;
+re (r/*0:101*/<:t/*0:11*/) = r/*0:101*/*sin t/*0:11*/;
+re x/*0:1*/::int = x/*0:1*/;
+re x/*0:1*/::bigint = x/*0:1*/;
+re x/*0:1*/::double = x/*0:1*/;
+im (x/*0:101*/+:y/*0:11*/) = y/*0:11*/;
+im (r/*0:101*/<:t/*0:11*/) = r/*0:101*/*cos t/*0:11*/;
+im x/*0:1*/::int = 0;
+im x/*0:1*/::bigint = 0L;
+im x/*0:1*/::double = 0.0;
+conj (x/*0:101*/+:y/*0:11*/) = x/*0:101*/+:-y/*0:11*/;
+conj (r/*0:101*/<:t/*0:11*/) = r/*0:101*/<:-t/*0:11*/;
+conj x/*0:1*/::int = x/*0:1*/;
+conj x/*0:1*/::bigint = x/*0:1*/;
+conj x/*0:1*/::double = x/*0:1*/;
+sqrt (x/*0:101*/+:y/*0:11*/) = sqrt (x/*0:101*/*x/*0:101*/+y/*0:11*/*y/*0:11*/)*(cos (t/2)+:sin (t/2));
+sqrt (r/*0:101*/<:t/*0:11*/) = sqrt r/*0:101*/<:t/*0:11*//2;
+sqrt x/*0:1*/::double = 0.0+:sqrt (-x/*0:1*/) if x/*0:1*/<0;
+exp (x/*0:101*/+:y/*0:11*/) = exp x/*0:101*/*(cos y/*0:11*/+:sin y/*0:11*/);
+exp (r/*0:101*/<:t/*0:11*/) = exp (r/*0:101*/*cos t/*0:11*/)<:r/*0:101*/*sin t/*0:11*/;
+ln z@(x/*0:101*/+:y/*0:11*/) = ln (abs z/*0:1*/)+:arg z/*0:1*/;
+ln (r/*0:101*/<:t/*0:11*/) = polar (ln r/*0:101*/+:t/*0:11*/);
+log z@(x/*0:101*/+:y/*0:11*/) = ln z/*0:1*//ln 10;
+log z@(r/*0:101*/<:t/*0:11*/) = ln z/*0:1*//ln 10;
+ln x/*0:1*/::double = ln (abs x/*0:1*/)+:arg x/*0:1*/ if x/*0:1*/<0;
+log x/*0:1*/::double = ln x/*0:1*//ln 10 if x/*0:1*/<0;
+sin (x/*0:101*/+:y/*0:11*/) = sin x/*0:101*/*cosh y/*0:11*/+:cos x/*0:101*/*sinh y/*0:11*/;
+cos (x/*0:101*/+:y/*0:11*/) = cos x/*0:101*/*cosh y/*0:11*/+:-sin x/*0:101*/*sinh y/*0:11*/;
+tan (x/*0:101*/+:y/*0:11*/) = (sin (2*x/*0:101*/)+:sinh (2*y/*0:11*/))/(cos (2*x/*0:101*/)+cosh (2*y/*0:11*/));
+sin z@(r/*0:101*/<:t/*0:11*/) = polar$sin$rect z/*0:1*/;
+cos z@(r/*0:101*/<:t/*0:11*/) = polar$cos$rect z/*0:1*/;
+tan z@(r/*0:101*/<:t/*0:11*/) = polar$tan$rect z/*0:1*/;
+asin z@(x/*0:101*/+:y/*0:11*/) = -(0+:1)*ln ((0+:1)*z/*0:1*/+sqrt (1-z/*0:1*/*z/*0:1*/));
+asin z@(r/*0:101*/<:t/*0:11*/) = -(0+:1)*ln ((0+:1)*z/*0:1*/+sqrt (1-z/*0:1*/*z/*0:1*/));
+acos z@(x/*0:101*/+:y/*0:11*/) = -(0+:1)*ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/-1));
+acos z@(r/*0:101*/<:t/*0:11*/) = -(0+:1)*ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/-1));
+atan z@(x/*0:101*/+:y/*0:11*/) = 0.0+:inf if z/*0:1*/==0+:1;
+atan z@(r/*0:101*/<:t/*0:11*/) = 0.0+:inf if z/*0:1*/==0+:1;
+atan z@(x/*0:101*/+:y/*0:11*/) = 0.0+:-inf if z/*0:1*/==-(0+:1);
+atan z@(r/*0:101*/<:t/*0:11*/) = 0.0+:-inf if z/*0:1*/==-(0+:1);
+atan z@(x/*0:101*/+:y/*0:11*/) = -(0+:1)*0.5*ln ((1+(0+:1)*z/*0:1*/)/(1-(0+:1)*z/*0:1*/));
+atan z@(r/*0:101*/<:t/*0:11*/) = -(0+:1)*0.5*ln ((1+(0+:1)*z/*0:1*/)/(1-(0+:1)*z/*0:1*/));
+sinh (x/*0:101*/+:y/*0:11*/) = sinh x/*0:101*/*cos y/*0:11*/+:cosh x/*0:101*/*sin y/*0:11*/;
+cosh (x/*0:101*/+:y/*0:11*/) = cosh x/*0:101*/*cos y/*0:11*/+:sinh x/*0:101*/*sin y/*0:11*/;
+tanh (x/*0:101*/+:y/*0:11*/) = (sinh (2*x/*0:101*/)+:sin (2*y/*0:11*/))/(cosh (2*x/*0:101*/)+cos (2*y/*0:11*/));
+sinh z@(r/*0:101*/<:t/*0:11*/) = polar$sinh$rect z/*0:1*/;
+cosh z@(r/*0:101*/<:t/*0:11*/) = polar$cosh$rect z/*0:1*/;
+tanh z@(r/*0:101*/<:t/*0:11*/) = polar$tanh$rect z/*0:1*/;
+asinh z@(x/*0:101*/+:y/*0:11*/) = ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/+1));
+asinh z@(r/*0:101*/<:t/*0:11*/) = ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/+1));
+acosh z@(x/*0:101*/+:y/*0:11*/) = ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/-1));
+acosh z@(r/*0:101*/<:t/*0:11*/) = ln (z/*0:1*/+sqrt (z/*0:1*/*z/*0:1*/-1));
+atanh z@(x/*0:101*/+:y/*0:11*/) = inf+:0.0 if z/*0:1*/==1;
+atanh z@(r/*0:101*/<:t/*0:11*/) = inf+:0.0 if z/*0:1*/==1;
+atanh z@(x/*0:101*/+:y/*0:11*/) = -inf+:0.0 if z/*0:1*/==-1;
+atanh z@(r/*0:101*/<:t/*0:11*/) = -inf+:0.0 if z/*0:1*/==-1;
+atanh z@(x/*0:101*/+:y/*0:11*/) = ln ((1+z/*0:1*/)/(1-z/*0:1*/))/2;
+atanh z@(r/*0:101*/<:t/*0:11*/) = ln ((1+z/*0:1*/)/(1-z/*0:1*/))/2;
+acosh x/*0:1*/::double = acosh (x/*0:1*/+:0);
+atanh x/*0:1*/::double = atanh (x/*0:1*/+:0);
+-(x/*0:101*/+:y/*0:11*/) = -x/*0:101*/+:-y/*0:11*/;
+-(r/*0:101*/<:t/*0:11*/) = r/*0:101*/<:t/*0:11*/+3.14159265358979;
+(x1/*0:0101*/+:y1/*0:011*/)+(x2/*0:101*/+:y2/*0:11*/) = x1/*0:0101*/+x2/*0:101*/+:y1/*0:011*/+y2/*0:11*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)+z2@(r2/*0:101*/<:t2/*0:11*/) = polar$rect z1/*0:01*/+rect z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)-(x2/*0:101*/+:y2/*0:11*/) = x1/*0:0101*/-x2/*0:101*/+:y1/*0:011*/-y2/*0:11*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)-z2@(r2/*0:101*/<:t2/*0:11*/) = polar$rect z1/*0:01*/-rect z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)*(x2/*0:101*/+:y2/*0:11*/) = x1/*0:0101*/*x2/*0:101*/-y1/*0:011*/*y2/*0:11*/+:x1/*0:0101*/*y2/*0:11*/+y1/*0:011*/*x2/*0:101*/;
+(r1/*0:0101*/<:t1/*0:011*/)*(r2/*0:101*/<:t2/*0:11*/) = r1/*0:0101*/*r2/*0:101*/<:t1/*0:011*/+t2/*0:11*/;
+(x1/*0:0101*/+:y1/*0:011*/)/(x2/*0:101*/+:y2/*0:11*/) = (x1/*0:0101*/*x2/*0:101*/+y1/*0:011*/*y2/*0:11*/+:y1/*0:011*/*x2/*0:101*/-x1/*0:0101*/*y2/*0:11*/)/(x2/*0:101*/*x2/*0:101*/+y2/*0:11*/*y2/*0:11*/);
+(r1/*0:0101*/<:t1/*0:011*/)/(r2/*0:101*/<:t2/*0:11*/) = r1/*0:0101*//r2/*0:101*/<:t1/*0:011*/-t2/*0:11*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)+z2@(r2/*0:101*/<:t2/*0:11*/) = z1/*0:01*/+rect z2/*0:1*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)+z2@(x2/*0:101*/+:y2/*0:11*/) = rect z1/*0:01*/+z2/*0:1*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)-z2@(r2/*0:101*/<:t2/*0:11*/) = z1/*0:01*/-rect z2/*0:1*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)-z2@(x2/*0:101*/+:y2/*0:11*/) = rect z1/*0:01*/-z2/*0:1*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)*z2@(r2/*0:101*/<:t2/*0:11*/) = z1/*0:01*/*rect z2/*0:1*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)*z2@(x2/*0:101*/+:y2/*0:11*/) = rect z1/*0:01*/*z2/*0:1*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)/z2@(r2/*0:101*/<:t2/*0:11*/) = z1/*0:01*//rect z2/*0:1*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)/z2@(x2/*0:101*/+:y2/*0:11*/) = rect z1/*0:01*//z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)+x2/*0:1*/ = x1/*0:0101*/+x2/*0:1*/+:y1/*0:011*/;
+x1/*0:01*/+(x2/*0:101*/+:y2/*0:11*/) = x1/*0:01*/+x2/*0:101*/+:y2/*0:11*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)+x2/*0:1*/ = rect z1/*0:01*/+x2/*0:1*/;
+x1/*0:01*/+z2@(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/+rect z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)-x2/*0:1*/ = x1/*0:0101*/-x2/*0:1*/+:y1/*0:011*/;
+x1/*0:01*/-(x2/*0:101*/+:y2/*0:11*/) = x1/*0:01*/-x2/*0:101*/+:-y2/*0:11*/;
+z1@(r1/*0:0101*/<:t1/*0:011*/)-x2/*0:1*/ = rect z1/*0:01*/-x2/*0:1*/;
+x1/*0:01*/-z2@(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/-rect z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)*x2/*0:1*/ = x1/*0:0101*/*x2/*0:1*/+:y1/*0:011*/*x2/*0:1*/;
+x1/*0:01*/*(x2/*0:101*/+:y2/*0:11*/) = x1/*0:01*/*x2/*0:101*/+:x1/*0:01*/*y2/*0:11*/;
+(r1/*0:0101*/<:t1/*0:011*/)*x2/*0:1*/ = r1/*0:0101*/*x2/*0:1*/<:t1/*0:011*/;
+x1/*0:01*/*(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/*r2/*0:101*/<:t2/*0:11*/;
+(x1/*0:0101*/+:y1/*0:011*/)/x2/*0:1*/ = x1/*0:0101*//x2/*0:1*/+:y1/*0:011*//x2/*0:1*/;
+x1/*0:01*//z2@(x2/*0:101*/+:y2/*0:11*/) = (x1/*0:01*/*x2/*0:101*/+:-x1/*0:01*/*y2/*0:11*/)/(x2/*0:101*/*x2/*0:101*/+y2/*0:11*/*y2/*0:11*/);
+(r1/*0:0101*/<:t1/*0:011*/)/x2/*0:1*/ = r1/*0:0101*//x2/*0:1*/<:t1/*0:011*/;
+x1/*0:01*//(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*//r2/*0:101*/<:-t2/*0:11*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)^z2@(x2/*0:101*/+:y2/*0:11*/) = polar z1/*0:01*/^z2/*0:1*/;
+z1@(x1/*0:0101*/+:y1/*0:011*/)^z2@(r2/*0:101*/<:t2/*0:11*/) = polar z1/*0:01*/^rect z2/*0:1*/;
+(r1/*0:0101*/<:t1/*0:011*/)^z2@(x2/*0:101*/+:y2/*0:11*/) = exp (ln r1/*0:0101*/*z2/*0:1*/)*exp ((0+:t1/*0:011*/)*z2/*0:1*/);
+(r1/*0:0101*/<:t1/*0:011*/)^z2@(r2/*0:101*/<:t2/*0:11*/) = exp (ln r1/*0:0101*/*z2/*0:1*/)*exp ((0+:t1/*0:011*/)*z2/*0:1*/);
+z1@(x1/*0:0101*/+:y1/*0:011*/)^x2/*0:1*/ = z1/*0:01*/^(x2/*0:1*/+:0);
+x1/*0:01*/^z2@(x2/*0:101*/+:y2/*0:11*/) = (x1/*0:01*/+:0)^z2/*0:1*/;
+(r1/*0:0101*/<:t1/*0:011*/)^x2/*0:1*/ = r1/*0:0101*/^x2/*0:1*/<:t1/*0:011*/*x2/*0:1*/;
+x1/*0:01*/^z2@(r2/*0:101*/<:t2/*0:11*/) = (x1/*0:01*/<:0)^z2/*0:1*/;
+x1/*0:01*/::double^x2/*0:1*/::double = exp (ln x1/*0:01*/*x2/*0:1*/) if x1/*0:01*/<0;
+x1/*0:0101*/+:y1/*0:011*/==x2/*0:101*/+:y2/*0:11*/ = x1/*0:0101*/==x2/*0:101*/&&y1/*0:011*/==y2/*0:11*/;
+r1/*0:0101*/<:t1/*0:011*/==r2/*0:101*/<:t2/*0:11*/ = r1/*0:0101*/==r2/*0:101*/&&t1/*0:011*/==t2/*0:11*/;
+x1/*0:0101*/+:y1/*0:011*/!=x2/*0:101*/+:y2/*0:11*/ = x1/*0:0101*/!=x2/*0:101*/||y1/*0:011*/!=y2/*0:11*/;
+r1/*0:0101*/<:t1/*0:011*/!=r2/*0:101*/<:t2/*0:11*/ = r1/*0:0101*/!=r2/*0:101*/||t1/*0:011*/!=t2/*0:11*/;
+z1@(_/*0:0101*/+:_/*0:011*/)==z2@(_/*0:101*/<:_/*0:11*/) = z1/*0:01*/==rect z2/*0:1*/;
+z1@(_/*0:0101*/<:_/*0:011*/)==z2@(_/*0:101*/+:_/*0:11*/) = rect z1/*0:01*/==z2/*0:1*/;
+z1@(_/*0:0101*/+:_/*0:011*/)!=z2@(_/*0:101*/<:_/*0:11*/) = z1/*0:01*/!=rect z2/*0:1*/;
+z1@(_/*0:0101*/<:_/*0:011*/)!=z2@(_/*0:101*/+:_/*0:11*/) = rect z1/*0:01*/!=z2/*0:1*/;
+x1/*0:0101*/+:y1/*0:011*/==x2/*0:1*/ = x1/*0:0101*/==x2/*0:1*/&&y1/*0:011*/==0;
+x1/*0:01*/==x2/*0:101*/+:y2/*0:11*/ = x1/*0:01*/==x2/*0:101*/&&y2/*0:11*/==0;
+z1@(r1/*0:0101*/<:t1/*0:011*/)==x2/*0:1*/ = z1/*0:01*/==x2/*0:1*/<:0;
+x1/*0:01*/==z2@(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/<:0==z2/*0:1*/;
+x1/*0:0101*/+:y1/*0:011*/!=x2/*0:1*/ = x1/*0:0101*/!=x2/*0:1*/||y1/*0:011*/!=0;
+x1/*0:01*/!=x2/*0:101*/+:y2/*0:11*/ = x1/*0:01*/!=x2/*0:101*/||y2/*0:11*/!=0;
+z1@(r1/*0:0101*/<:t1/*0:011*/)!=x2/*0:1*/ = z1/*0:01*/!=x2/*0:1*/<:0;
+x1/*0:01*/!=z2@(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/<:0!=z2/*0:1*/;
+x/*0:01*/::bigint%0L = x/*0:01*//0;
+x/*0:01*/::bigint%y/*0:1*/::bigint = (-x/*0:01*/)%(-y/*0:1*/) if y/*0:1*/<0;
+x/*0:01*/::bigint%y/*0:1*/::bigint = x/*1:01*/ div d/*0:*/%(y/*1:1*/ div d/*0:*/) when d/*0:*/ = gcd x/*0:01*/ y/*0:1*/ {
+ rule #0: d = gcd x y
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end if gcd x/*0:01*/ y/*0:1*/>1;
+x/*0:01*/::int%y/*0:1*/::bigint = bigint x/*0:01*/%y/*0:1*/;
+x/*0:01*/::bigint%y/*0:1*/::int = x/*0:01*/%bigint y/*0:1*/;
+x/*0:01*/::int%y/*0:1*/::int = bigint x/*0:01*/%bigint y/*0:1*/;
+x1/*0:0101*/%y1/*0:011*/%(x2/*0:101*/%y2/*0:11*/) = x1/*0:0101*/*y2/*0:11*/%(y1/*0:011*/*x2/*0:101*/);
+x1/*0:0101*/%y1/*0:011*/%x2/*0:1*/ = x1/*0:0101*/%(y1/*0:011*/*x2/*0:1*/);
+x1/*0:01*/%(x2/*0:101*/%y2/*0:11*/) = x1/*0:01*/*y2/*0:11*/%x2/*0:101*/;
+z1@(_/*0:0101*/+:_/*0:011*/)%z2@(_/*0:101*/<:_/*0:11*/) = z1/*0:01*//z2/*0:1*/;
+z1@(_/*0:0101*/<:_/*0:011*/)%z2@(_/*0:101*/+:_/*0:11*/) = z1/*0:01*//z2/*0:1*/;
+(x1/*0:0101*/+:y1/*0:011*/)%(x2/*0:101*/+:y2/*0:11*/) = (x1/*1:0101*/*x2/*1:101*/+y1/*1:011*/*y2/*1:11*/)%d/*0:*/+:(y1/*1:011*/*x2/*1:101*/-x1/*1:0101*/*y2/*1:11*/)%d/*0:*/ when d/*0:*/ = x2/*0:101*/*x2/*0:101*/+y2/*0:11*/*y2/*0:11*/ {
+ rule #0: d = x2*x2+y2*y2
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+(x1/*0:0101*/+:y1/*0:011*/)%x2/*0:1*/ = x1/*1:0101*/*x2/*1:1*/%d/*0:*/+:y1/*1:011*/*x2/*1:1*/%d/*0:*/ when d/*0:*/ = x2/*0:1*/*x2/*0:1*/ {
+ rule #0: d = x2*x2
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+x1/*0:01*/%(x2/*0:101*/+:y2/*0:11*/) = x1/*1:01*/*x2/*1:101*/%d/*0:*/+:(-x1/*1:01*/*y2/*1:11*/)%d/*0:*/ when d/*0:*/ = x2/*0:101*/*x2/*0:101*/+y2/*0:11*/*y2/*0:11*/ {
+ rule #0: d = x2*x2+y2*y2
+ state 0: #0
+ <var> state 1
+ state 1: #0
+} end;
+(r1/*0:0101*/<:t1/*0:011*/)%(r2/*0:101*/<:t2/*0:11*/) = r1/*0:0101*/%r2/*0:101*/<:t1/*0:011*/-t2/*0:11*/;
+(r1/*0:0101*/<:t1/*0:011*/)%x2/*0:1*/ = r1/*0:0101*/%x2/*0:1*/<:t1/*0:011*/;
+x1/*0:01*/%(r2/*0:101*/<:t2/*0:11*/) = x1/*0:01*/%r2/*0:101*/<:-t2/*0:11*/;
+x/*0:01*/::double%y/*0:1*/ = x/*0:01*//y/*0:1*/;
+x/*0:01*/%y/*0:1*/::double = x/*0:01*//y/*0:1*/;
+rational x@(_/*0:101*/%_/*0:11*/) = x/*0:1*/;
+rational x/*0:1*/::int = x/*0:1*/%1;
+rational x/*0:1*/::bigint = x/*0:1*/%1;
+rational x/*0:1*/::double = x/*0:1*/;
+rational (x/*0:101*/+:y/*0:11*/) = rational x/*0:101*/+:rational y/*0:11*/;
+rational (x/*0:101*/<:y/*0:11*/) = rational x/*0:101*/<:rational y/*0:11*/;
+int x@(_/*0:101*/%_/*0:11*/) = int (bigint x/*0:1*/);
+bigint x@(_/*0:101*/%_/*0:11*/) = trunc x/*0:1*/;
+double (x/*0:101*/%y/*0:11*/) = x/*0:101*//y/*0:11*/;
+complex (x/*0:101*/%y/*0:11*/) = x/*0:101*/%y/*0:11*/+:0L%1L;
+rect (x/*0:101*/%y/*0:11*/) = x/*0:101*/%y/*0:11*/+:0L%1L;
+polar (x/*0:101*/%y/*0:11*/) = x/*0:101*/%y/*0:11*/<:0L%1L;
+r@(_/*0:0101*/%_/*0:011*/)<:t/*0:1*/ = -r/*0:01*/<:t/*0:1*/+3.14159265358979 if r/*0:01*/<0;
+r/*0:01*/<:t@(_/*0:101*/%_/*0:11*/) = r/*0:01*/<:atan2 (sin t/*0:1*/) (cos t/*0:1*/) if t/*0:1*/<-3.14159265358979||t/*0:1*/>3.14159265358979;
+r/*0:01*/<:t@(_/*0:101*/%_/*0:11*/) = r/*0:01*/<:3.14159265358979 if t/*0:1*/==-3.14159265358979;
+num (x/*0:101*/%y/*0:11*/) = x/*0:101*/;
+den (x/*0:101*/%y/*0:11*/) = y/*0:11*/;
+num x/*0:1*/::int = x/*0:1*/;
+num x/*0:1*/::bigint = x/*0:1*/;
+den x/*0:1*/::int = 1;
+den x/*0:1*/::bigint = 1;
+abs (x/*0:101*/%y/*0:11*/) = abs x/*0:101*/%y/*0:11*/;
+sgn (x/*0:101*/%y/*0:11*/) = sgn x/*0:101*/;
+floor x@(_/*0:101*/%_/*0:11*/) = if n/*0:*/<=x/*1:1*/ then n/*0:*/ else n/*0:*/-1 when n/*0:*/::bigint = trunc x/*0:1*/ {
+ rule #0: n::bigint = trunc x
+ state 0: #0
+ <var>::bigint state 1
+ state 1: #0
+} end;
+ceil x@(_/*0:101*/%_/*0:11*/) = -floor (-x/*0:1*/);
+round (x/*0:101*/%y/*0:11*/) = -round ((-x/*0:101*/)%y/*0:11*/) if x/*0:101*/<0;
+round (x/*0:101*/%y/*0:11*/) = x/*0:101*/ div 2+1 if y/*0:11*/==2;
+round (x/*0:101*/%y/*0:11*/) = (2*x/*0:101*/+y/*0:11*/) div (2*y/*0:11*/);
+trunc (x/*0:101*/%y/*0:11*/) = x/*0:101*/ div y/*0:11*/;
+frac x@(_/*0:101*/%_/*0:11*/) = x/*0:1*/-trunc x/*0:1*/;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::int = pow x/*0:0101*/ n/*0:1*/%pow y/*0:011*/ n/*0:1*/ if n/*0:1*/>0;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::bigint = pow x/*0:0101*/ n/*0:1*/%pow y/*0:011*/ n/*0:1*/ if n/*0:1*/>0;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::int = pow y/*0:011*/ (-n/*0:1*/)%pow x/*0:0101*/ (-n/*0:1*/) if n/*0:1*/<0;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::bigint = pow y/*0:011*/ (-n/*0:1*/)%pow x/*0:0101*/ (-n/*0:1*/) if n/*0:1*/<0;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::int = 1L%1L;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::bigint = 1L%1L;
+pow (x/*0:0101*/%y/*0:011*/) n/*0:1*/::double = pow (x/*0:0101*//y/*0:011*/) n/*0:1*/;
+pow (x/*0:0101*/%y/*0:011*/) (n/*0:101*/%m/*0:11*/) = pow (x/*0:0101*//y/*0:011*/) (n/*0:101*//m/*0:11*/);
+pow x/*0:01*/::int n/*0:1*/::int = 1%pow x/*0:01*/ (-n/*0:1*/) if n/*0:1*/<0;
+pow x/*0:01*/::int n/*0:1*/::bigint = 1%pow x/*0:01*/ (-n/*0:1*/) if n/*0:1*/<0;
+pow x/*0:01*/::bigint n/*0:1*/::int = 1%pow x/*0:01*/ (-n/*0:1*/) if n/*0:1*/<0;
+pow x/*0:01*/::bigint n/*0:1*/::bigint = 1%pow x/*0:01*/ (-n/*0:1*/) if n/*0:1*/<0;
+sqrt (x/*0:101*/%y/*0:11*/) = sqrt (x/*0:101*//y/*0:11*/);
+exp (x/*0:101*/%y/*0:11*/) = exp (x/*0:101*//y/*0:11*/);
+ln (x/*0:101*/%y/*0:11*/) = ln (x/*0:101*//y/*0:11*/);
+log (x/*0:101*/%y/*0:11*/) = log (x/*0:101*//y/*0:11*/);
+sin (x/*0:101*/%y/*0:11*/) = sin (x/*0:101*//y/*0:11*/);
+cos (x/*0:101*/%y/*0:11*/) = cos (x/*0:101*//y/*0:11*/);
+tan (x/*0:101*/%y/*0:11*/) = tan (x/*0:101*//y/*0:11*/);
+asin (x/*0:101*/%y/*0:11*/) = asin (x/*0:101*//y/*0:11*/);
+acos (x/*0:101*/%y/*0:11*/) = acos (x/*0:101*//y/*0:11*/);
+atan (x/*0:101*/%y/*0:11*/) = atan (x/*0:101*//y/*0:11*/);
+atan2 (x/*0:0101*/%y/*0:011*/) z/*0:1*/ = atan2 (x/*0:0101*//y/*0:011*/) z/*0:1*/;
+atan2 x/*0:01*/ (y/*0:101*/%z/*0:11*/) = atan2 x/*0:01*/ (y/*0:101*//z/*0:11*/);
+sinh (x/*0:101*/%y/*0:11*/) = sinh (x/*0:101*//y/*0:11*/);
+cosh (x/*0:101*/%y/*0:11*/) = cosh (x/*0:101*//y/*0:11*/);
+tanh (x/*0:101*/%y/*0:11*/) = tanh (x/*0:101*//y/*0:11*/);
+asinh (x/*0:101*/%y/*0:11*/) = asinh (x/*0:101*//y/*0:11*/);
+acosh (x/*0:101*/%y/*0:11*/) = acosh (x/*0:101*//y/*0:11*/);
+atanh (x/*0:101*/%y/*0:11*/) = atanh (x/*0:101*//y/*0:11*/);
+-x/*0:101*/%y/*0:11*/ = (-x/*0:101*/)%y/*0:11*/;
+x1/*0:0101*/%y1/*0:011*/+x2/*0:101*/%y2/*0:11*/ = (x1/*0:0101*/*y2/*0:11*/+x2/*0:101*/*y1/*0:011*/)%(y1/*0:011*/*y2/*0:11*/);
+x1/*0:0101*/%y1/*0:011*/-x2/*0:101*/%y2/*0:11*/ = (x1/*0:0101*/*y2/*0:11*/-x2/*0:101*/*y1/*0:011*/)%(y1/*0:011*/*y2/*0:11*/);
+x1/*0:0101*/%y1/*0:011*/*(x2/*0:101*/%y2/*0:11*/) = x1/*0:0101*/*x2/*0:101*/%(y1/*0:011*/*y2/*0:11*/);
+x1/*0:0101*/%y1/*0:011*/+x2/*0:1*/ = (x1/*0:0101*/+x2/*0:1*/*y1/*0:011*/)%y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/-x2/*0:1*/ = (x1/*0:0101*/-x2/*0:1*/*y1/*0:011*/)%y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/*x2/*0:1*/ = x1/*0:0101*/*x2/*0:1*/%y1/*0:011*/;
+x1/*0:01*/+x2/*0:101*/%y2/*0:11*/ = (x1/*0:01*/*y2/*0:11*/+x2/*0:101*/)%y2/*0:11*/;
+x1/*0:01*/-x2/*0:101*/%y2/*0:11*/ = (x1/*0:01*/*y2/*0:11*/-x2/*0:101*/)%y2/*0:11*/;
+x1/*0:01*/*(x2/*0:101*/%y2/*0:11*/) = x1/*0:01*/*x2/*0:101*/%y2/*0:11*/;
+x1/*0:0101*/%y1/*0:011*//(x2/*0:101*/%y2/*0:11*/) = x1/*0:0101*/*y2/*0:11*//(y1/*0:011*/*x2/*0:101*/);
+(x1/*0:0101*/%y1/*0:011*/)^(x2/*0:101*/%y2/*0:11*/) = (x1/*0:0101*//y1/*0:011*/)^(x2/*0:101*//y2/*0:11*/);
+x1/*0:0101*/%y1/*0:011*//x2/*0:1*/ = x1/*0:0101*//(y1/*0:011*/*x2/*0:1*/);
+(x1/*0:0101*/%y1/*0:011*/)^x2/*0:1*/ = (x1/*0:0101*//y1/*0:011*/)^x2/*0:1*/;
+x1/*0:01*//(x2/*0:101*/%y2/*0:11*/) = x1/*0:01*/*y2/*0:11*//x2/*0:101*/;
+x1/*0:01*/^(x2/*0:101*/%y2/*0:11*/) = x1/*0:01*/^(x2/*0:101*//y2/*0:11*/);
+x1/*0:0101*/%y1/*0:011*/==x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/==x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/!=x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/!=x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/<x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/<x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/<=x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/<=x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/>x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/>x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/>=x2/*0:101*/%y2/*0:11*/ = x1/*0:0101*/*y2/*0:11*/>=x2/*0:101*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/==x2/*0:1*/ = x1/*0:0101*/==x2/*0:1*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/!=x2/*0:1*/ = x1/*0:0101*/!=x2/*0:1*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/<x2/*0:1*/ = x1/*0:0101*/<x2/*0:1*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/<=x2/*0:1*/ = x1/*0:0101*/<=x2/*0:1*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/>x2/*0:1*/ = x1/*0:0101*/>x2/*0:1*/*y1/*0:011*/;
+x1/*0:0101*/%y1/*0:011*/>=x2/*0:1*/ = x1/*0:0101*/>=x2/*0:1*/*y1/*0:011*/;
+x1/*0:01*/==x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/==x2/*0:101*/;
+x1/*0:01*/!=x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/!=x2/*0:101*/;
+x1/*0:01*/<x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/<x2/*0:101*/;
+x1/*0:01*/<=x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/<=x2/*0:101*/;
+x1/*0:01*/>x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/>x2/*0:101*/;
+x1/*0:01*/>=x2/*0:101*/%y2/*0:11*/ = x1/*0:01*/*y2/*0:11*/>=x2/*0:101*/;
+complexp x/*0:1*/ = case x/*0:1*/ of x/*0:01*/+:y/*0:1*/ = realp x/*0:01*/&&realp y/*0:1*/; x/*0:01*/<:y/*0:1*/ = realp x/*0:01*/&&realp y/*0:1*/; _/*0:*/ = 0 {
+ rule #0: x+:y = realp x&&realp y
+ rule #1: x<:y = realp x&&realp y
+ rule #2: _ = 0
+ state 0: #0 #1 #2
+ <var> state 1
+ <app> state 2
+ state 1: #2
+ state 2: #0 #1 #2
+ <var> state 3
+ <app> state 5
+ state 3: #2
+ <var> state 4
+ state 4: #2
+ state 5: #0 #1 #2
+ <var> state 6
+ +: state 9
+ <: state 12
+ state 6: #2
+ <var> state 7
+ state 7: #2
+ <var> state 8
+ state 8: #2
+ state 9: #0 #2
+ <var> state 10
+ state 10: #0 #2
+ <var> state 11
+ state 11: #0 #2
+ state 12: #1 #2
+ <var> state 13
+ state 13: #1 #2
+ <var> state 14
+ state 14: #1 #2
+} end;
+rationalp x/*0:1*/ = case x/*0:1*/ of x/*0:01*/%y/*0:1*/ = bigintp x/*0:01*/&&bigintp y/*0:1*/; _/*0:*/ = 0 {
+ rule #0: x%y = bigintp x&&bigintp y
+ rule #1: _ = 0
+ state 0: #0 #1
+ <var> state 1
+ <app> state 2
+ state 1: #1
+ state 2: #0 #1
+ <var> state 3
+ <app> state 5
+ state 3: #1
+ <var> state 4
+ state 4: #1
+ state 5: #0 #1
+ <var> state 6
+ % state 9
+ state 6: #1
+ <var> state 7
+ state 7: #1
+ <var> state 8
+ state 8: #1
+ state 9: #0 #1
+ <var> state 10
+ state 10: #0 #1
+ <var> state 11
+ state 11: #0 #1
+} end;
+realp x/*0:1*/ = intp x/*0:1*/||bigintp x/*0:1*/||doublep x/*0:1*/||rationalp x/*0:1*/;
+numberp x/*0:1*/ = realp x/*0:1*/||complexp x/*0:1*/;
+exactp x/*0:1*/ = intp x/*0:1*/||bigintp x/*0:1*/||rationalp||complexp x/*0:1*/&&exactp (re x/*0:1*/)&&exactp (im x/*0:1*/) if numberp x/*0:1*/;
+infp x/*0:1*/::double = not nanp x/*0:1*/&&nanp (x/*0:1*/-x/*0:1*/);
+nanp x/*0:1*/::double = x/*0:1*/===nan;
+{
+ rule #0: x::int<y::int = x<y
+ rule #1: x::double<y::double = x<y
+ rule #2: x::int<y::double = x<y
+ rule #3: x::double<y::int = x<y
+ rule #4: x::bigint<y::bigint = bigint_cmp x y<0
+ rule #5: x::int<y::bigint = bigint x<y
+ rule #6: x::bigint<y::int = x<bigint y
+ rule #7: x::bigint<y::double = double x<y
+ rule #8: x::double<y::bigint = x<double y
+ rule #9: x<y = bigint x<bigint y
+ rule #10: x::string<y::string = strcmp x y<0
+ rule #11: x1%y1<x2%y2 = x1*y2<x2*y1
+ rule #12: x1%y1<x2 = x1<x2*y1
+ rule #13: x1<x2%y2 = x1*y2<x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13
+ <var> state 1
+ <var>::int state 7
+ <var>::bigint state 16
+ <var>::double state 25
+ <var>::string state 34
+ <var> state 41
+ <app> state 48
+ state 1: #13
+ <app> state 2
+ state 2: #13
+ <app> state 3
+ state 3: #13
+ % state 4
+ state 4: #13
+ <var> state 5
+ state 5: #13
+ <var> state 6
+ state 6: #13
+ state 7: #0 #2 #5 #13
+ <var>::int state 8
+ <var>::bigint state 9
+ <var>::double state 10
+ <app> state 11
+ state 8: #0
+ state 9: #5
+ state 10: #2
+ state 11: #13
+ <app> state 12
+ state 12: #13
+ % state 13
+ state 13: #13
+ <var> state 14
+ state 14: #13
+ <var> state 15
+ state 15: #13
+ state 16: #4 #6 #7 #13
+ <var>::int state 17
+ <var>::bigint state 18
+ <var>::double state 19
+ <app> state 20
+ state 17: #6
+ state 18: #4
+ state 19: #7
+ state 20: #13
+ <app> state 21
+ state 21: #13
+ % state 22
+ state 22: #13
+ <var> state 23
+ state 23: #13
+ <var> state 24
+ state 24: #13
+ state 25: #1 #3 #8 #13
+ <var>::int state 26
+ <var>::bigint state 27
+ <var>::double state 28
+ <app> state 29
+ state 26: #3
+ state 27: #8
+ state 28: #1
+ state 29: #13
+ <app> state 30
+ state 30: #13
+ % state 31
+ state 31: #13
+ <var> state 32
+ state 32: #13
+ <var> state 33
+ state 33: #13
+ state 34: #10 #13
+ <var>::string state 35
+ <app> state 36
+ state 35: #10
+ state 36: #13
+ <app> state 37
+ state 37: #13
+ % state 38
+ state 38: #13
+ <var> state 39
+ state 39: #13
+ <var> state 40
+ state 40: #13
+ state 41: #9 #13
+ <var> state 42
+ <app> state 43
+ state 42: #9
+ state 43: #13
+ <app> state 44
+ state 44: #13
+ % state 45
+ state 45: #13
+ <var> state 46
+ state 46: #13
+ <var> state 47
+ state 47: #13
+ state 48: #11 #12 #13
+ <var> state 49
+ <app> state 56
+ state 49: #13
+ <var> state 50
+ state 50: #13
+ <app> state 51
+ state 51: #13
+ <app> state 52
+ state 52: #13
+ % state 53
+ state 53: #13
+ <var> state 54
+ state 54: #13
+ <var> state 55
+ state 55: #13
+ state 56: #11 #12 #13
+ <var> state 57
+ % state 65
+ state 57: #13
+ <var> state 58
+ state 58: #13
+ <var> state 59
+ state 59: #13
+ <app> state 60
+ state 60: #13
+ <app> state 61
+ state 61: #13
+ % state 62
+ state 62: #13
+ <var> state 63
+ state 63: #13
+ <var> state 64
+ state 64: #13
+ state 65: #11 #12 #13
+ <var> state 66
+ state 66: #11 #12 #13
+ <var> state 67
+ state 67: #11 #12 #13
+ <var> state 68
+ <app> state 69
+ state 68: #12
+ state 69: #11 #12 #13
+ <var> state 70
+ <app> state 72
+ state 70: #12
+ <var> state 71
+ state 71: #12
+ state 72: #11 #12 #13
+ <var> state 73
+ % state 76
+ state 73: #12
+ <var> state 74
+ state 74: #12
+ <var> state 75
+ state 75: #12
+ state 76: #11 #12 #13
+ <var> state 77
+ state 77: #11 #12 #13
+ <var> state 78
+ state 78: #11 #12 #13
+}
+{
+ rule #0: x::int>y::int = x>y
+ rule #1: x::double>y::double = x>y
+ rule #2: x::int>y::double = x>y
+ rule #3: x::double>y::int = x>y
+ rule #4: x::bigint>y::bigint = bigint_cmp x y>0
+ rule #5: x::int>y::bigint = bigint x>y
+ rule #6: x::bigint>y::int = x>bigint y
+ rule #7: x::bigint>y::double = double x>y
+ rule #8: x::double>y::bigint = x>double y
+ rule #9: x>y = bigint x>bigint y
+ rule #10: x::string>y::string = strcmp x y>0
+ rule #11: x1%y1>x2%y2 = x1*y2>x2*y1
+ rule #12: x1%y1>x2 = x1>x2*y1
+ rule #13: x1>x2%y2 = x1*y2>x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13
+ <var> state 1
+ <var>::int state 7
+ <var>::bigint state 16
+ <var>::double state 25
+ <var>::string state 34
+ <var> state 41
+ <app> state 48
+ state 1: #13
+ <app> state 2
+ state 2: #13
+ <app> state 3
+ state 3: #13
+ % state 4
+ state 4: #13
+ <var> state 5
+ state 5: #13
+ <var> state 6
+ state 6: #13
+ state 7: #0 #2 #5 #13
+ <var>::int state 8
+ <var>::bigint state 9
+ <var>::double state 10
+ <app> state 11
+ state 8: #0
+ state 9: #5
+ state 10: #2
+ state 11: #13
+ <app> state 12
+ state 12: #13
+ % state 13
+ state 13: #13
+ <var> state 14
+ state 14: #13
+ <var> state 15
+ state 15: #13
+ state 16: #4 #6 #7 #13
+ <var>::int state 17
+ <var>::bigint state 18
+ <var>::double state 19
+ <app> state 20
+ state 17: #6
+ state 18: #4
+ state 19: #7
+ state 20: #13
+ <app> state 21
+ state 21: #13
+ % state 22
+ state 22: #13
+ <var> state 23
+ state 23: #13
+ <var> state 24
+ state 24: #13
+ state 25: #1 #3 #8 #13
+ <var>::int state 26
+ <var>::bigint state 27
+ <var>::double state 28
+ <app> state 29
+ state 26: #3
+ state 27: #8
+ state 28: #1
+ state 29: #13
+ <app> state 30
+ state 30: #13
+ % state 31
+ state 31: #13
+ <var> state 32
+ state 32: #13
+ <var> state 33
+ state 33: #13
+ state 34: #10 #13
+ <var>::string state 35
+ <app> state 36
+ state 35: #10
+ state 36: #13
+ <app> state 37
+ state 37: #13
+ % state 38
+ state 38: #13
+ <var> state 39
+ state 39: #13
+ <var> state 40
+ state 40: #13
+ state 41: #9 #13
+ <var> state 42
+ <app> state 43
+ state 42: #9
+ state 43: #13
+ <app> state 44
+ state 44: #13
+ % state 45
+ state 45: #13
+ <var> state 46
+ state 46: #13
+ <var> state 47
+ state 47: #13
+ state 48: #11 #12 #13
+ <var> state 49
+ <app> state 56
+ state 49: #13
+ <var> state 50
+ state 50: #13
+ <app> state 51
+ state 51: #13
+ <app> state 52
+ state 52: #13
+ % state 53
+ state 53: #13
+ <var> state 54
+ state 54: #13
+ <var> state 55
+ state 55: #13
+ state 56: #11 #12 #13
+ <var> state 57
+ % state 65
+ state 57: #13
+ <var> state 58
+ state 58: #13
+ <var> state 59
+ state 59: #13
+ <app> state 60
+ state 60: #13
+ <app> state 61
+ state 61: #13
+ % state 62
+ state 62: #13
+ <var> state 63
+ state 63: #13
+ <var> state 64
+ state 64: #13
+ state 65: #11 #12 #13
+ <var> state 66
+ state 66: #11 #12 #13
+ <var> state 67
+ state 67: #11 #12 #13
+ <var> state 68
+ <app> state 69
+ state 68: #12
+ state 69: #11 #12 #13
+ <var> state 70
+ <app> state 72
+ state 70: #12
+ <var> state 71
+ state 71: #12
+ state 72: #11 #12 #13
+ <var> state 73
+ % state 76
+ state 73: #12
+ <var> state 74
+ state 74: #12
+ <var> state 75
+ state 75: #12
+ state 76: #11 #12 #13
+ <var> state 77
+ state 77: #11 #12 #13
+ <var> state 78
+ state 78: #11 #12 #13
+}
+{
+ rule #0: x::int<=y::int = x<=y
+ rule #1: x::double<=y::double = x<=y
+ rule #2: x::int<=y::double = x<=y
+ rule #3: x::double<=y::int = x<=y
+ rule #4: x::bigint<=y::bigint = bigint_cmp x y<=0
+ rule #5: x::int<=y::bigint = bigint x<=y
+ rule #6: x::bigint<=y::int = x<=bigint y
+ rule #7: x::bigint<=y::double = double x<=y
+ rule #8: x::double<=y::bigint = x<=double y
+ rule #9: x<=y = bigint x<=bigint y
+ rule #10: x::string<=y::string = strcmp x y<=0
+ rule #11: x1%y1<=x2%y2 = x1*y2<=x2*y1
+ rule #12: x1%y1<=x2 = x1<=x2*y1
+ rule #13: x1<=x2%y2 = x1*y2<=x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13
+ <var> state 1
+ <var>::int state 7
+ <var>::bigint state 16
+ <var>::double state 25
+ <var>::string state 34
+ <var> state 41
+ <app> state 48
+ state 1: #13
+ <app> state 2
+ state 2: #13
+ <app> state 3
+ state 3: #13
+ % state 4
+ state 4: #13
+ <var> state 5
+ state 5: #13
+ <var> state 6
+ state 6: #13
+ state 7: #0 #2 #5 #13
+ <var>::int state 8
+ <var>::bigint state 9
+ <var>::double state 10
+ <app> state 11
+ state 8: #0
+ state 9: #5
+ state 10: #2
+ state 11: #13
+ <app> state 12
+ state 12: #13
+ % state 13
+ state 13: #13
+ <var> state 14
+ state 14: #13
+ <var> state 15
+ state 15: #13
+ state 16: #4 #6 #7 #13
+ <var>::int state 17
+ <var>::bigint state 18
+ <var>::double state 19
+ <app> state 20
+ state 17: #6
+ state 18: #4
+ state 19: #7
+ state 20: #13
+ <app> state 21
+ state 21: #13
+ % state 22
+ state 22: #13
+ <var> state 23
+ state 23: #13
+ <var> state 24
+ state 24: #13
+ state 25: #1 #3 #8 #13
+ <var>::int state 26
+ <var>::bigint state 27
+ <var>::double state 28
+ <app> state 29
+ state 26: #3
+ state 27: #8
+ state 28: #1
+ state 29: #13
+ <app> state 30
+ state 30: #13
+ % state 31
+ state 31: #13
+ <var> state 32
+ state 32: #13
+ <var> state 33
+ state 33: #13
+ state 34: #10 #13
+ <var>::string state 35
+ <app> state 36
+ state 35: #10
+ state 36: #13
+ <app> state 37
+ state 37: #13
+ % state 38
+ state 38: #13
+ <var> state 39
+ state 39: #13
+ <var> state 40
+ state 40: #13
+ state 41: #9 #13
+ <var> state 42
+ <app> state 43
+ state 42: #9
+ state 43: #13
+ <app> state 44
+ state 44: #13
+ % state 45
+ state 45: #13
+ <var> state 46
+ state 46: #13
+ <var> state 47
+ state 47: #13
+ state 48: #11 #12 #13
+ <var> state 49
+ <app> state 56
+ state 49: #13
+ <var> state 50
+ state 50: #13
+ <app> state 51
+ state 51: #13
+ <app> state 52
+ state 52: #13
+ % state 53
+ state 53: #13
+ <var> state 54
+ state 54: #13
+ <var> state 55
+ state 55: #13
+ state 56: #11 #12 #13
+ <var> state 57
+ % state 65
+ state 57: #13
+ <var> state 58
+ state 58: #13
+ <var> state 59
+ state 59: #13
+ <app> state 60
+ state 60: #13
+ <app> state 61
+ state 61: #13
+ % state 62
+ state 62: #13
+ <var> state 63
+ state 63: #13
+ <var> state 64
+ state 64: #13
+ state 65: #11 #12 #13
+ <var> state 66
+ state 66: #11 #12 #13
+ <var> state 67
+ state 67: #11 #12 #13
+ <var> state 68
+ <app> state 69
+ state 68: #12
+ state 69: #11 #12 #13
+ <var> state 70
+ <app> state 72
+ state 70: #12
+ <var> state 71
+ state 71: #12
+ state 72: #11 #12 #13
+ <var> state 73
+ % state 76
+ state 73: #12
+ <var> state 74
+ state 74: #12
+ <var> state 75
+ state 75: #12
+ state 76: #11 #12 #13
+ <var> state 77
+ state 77: #11 #12 #13
+ <var> state 78
+ state 78: #11 #12 #13
+}
+{
+ rule #0: x::int>=y::int = x>=y
+ rule #1: x::double>=y::double = x>=y
+ rule #2: x::int>=y::double = x>=y
+ rule #3: x::double>=y::int = x>=y
+ rule #4: x::bigint>=y::bigint = bigint_cmp x y>=0
+ rule #5: x::int>=y::bigint = bigint x>=y
+ rule #6: x::bigint>=y::int = x>=bigint y
+ rule #7: x::bigint>=y::double = double x>=y
+ rule #8: x::double>=y::bigint = x>=double y
+ rule #9: x>=y = bigint x>=bigint y
+ rule #10: x::string>=y::string = strcmp x y>=0
+ rule #11: x1%y1>=x2%y2 = x1*y2>=x2*y1
+ rule #12: x1%y1>=x2 = x1>=x2*y1
+ rule #13: x1>=x2%y2 = x1*y2>=x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13
+ <var> state 1
+ <var>::int state 7
+ <var>::bigint state 16
+ <var>::double state 25
+ <var>::string state 34
+ <var> state 41
+ <app> state 48
+ state 1: #13
+ <app> state 2
+ state 2: #13
+ <app> state 3
+ state 3: #13
+ % state 4
+ state 4: #13
+ <var> state 5
+ state 5: #13
+ <var> state 6
+ state 6: #13
+ state 7: #0 #2 #5 #13
+ <var>::int state 8
+ <var>::bigint state 9
+ <var>::double state 10
+ <app> state 11
+ state 8: #0
+ state 9: #5
+ state 10: #2
+ state 11: #13
+ <app> state 12
+ state 12: #13
+ % state 13
+ state 13: #13
+ <var> state 14
+ state 14: #13
+ <var> state 15
+ state 15: #13
+ state 16: #4 #6 #7 #13
+ <var>::int state 17
+ <var>::bigint state 18
+ <var>::double state 19
+ <app> state 20
+ state 17: #6
+ state 18: #4
+ state 19: #7
+ state 20: #13
+ <app> state 21
+ state 21: #13
+ % state 22
+ state 22: #13
+ <var> state 23
+ state 23: #13
+ <var> state 24
+ state 24: #13
+ state 25: #1 #3 #8 #13
+ <var>::int state 26
+ <var>::bigint state 27
+ <var>::double state 28
+ <app> state 29
+ state 26: #3
+ state 27: #8
+ state 28: #1
+ state 29: #13
+ <app> state 30
+ state 30: #13
+ % state 31
+ state 31: #13
+ <var> state 32
+ state 32: #13
+ <var> state 33
+ state 33: #13
+ state 34: #10 #13
+ <var>::string state 35
+ <app> state 36
+ state 35: #10
+ state 36: #13
+ <app> state 37
+ state 37: #13
+ % state 38
+ state 38: #13
+ <var> state 39
+ state 39: #13
+ <var> state 40
+ state 40: #13
+ state 41: #9 #13
+ <var> state 42
+ <app> state 43
+ state 42: #9
+ state 43: #13
+ <app> state 44
+ state 44: #13
+ % state 45
+ state 45: #13
+ <var> state 46
+ state 46: #13
+ <var> state 47
+ state 47: #13
+ state 48: #11 #12 #13
+ <var> state 49
+ <app> state 56
+ state 49: #13
+ <var> state 50
+ state 50: #13
+ <app> state 51
+ state 51: #13
+ <app> state 52
+ state 52: #13
+ % state 53
+ state 53: #13
+ <var> state 54
+ state 54: #13
+ <var> state 55
+ state 55: #13
+ state 56: #11 #12 #13
+ <var> state 57
+ % state 65
+ state 57: #13
+ <var> state 58
+ state 58: #13
+ <var> state 59
+ state 59: #13
+ <app> state 60
+ state 60: #13
+ <app> state 61
+ state 61: #13
+ % state 62
+ state 62: #13
+ <var> state 63
+ state 63: #13
+ <var> state 64
+ state 64: #13
+ state 65: #11 #12 #13
+ <var> state 66
+ state 66: #11 #12 #13
+ <var> state 67
+ state 67: #11 #12 #13
+ <var> state 68
+ <app> state 69
+ state 68: #12
+ state 69: #11 #12 #13
+ <var> state 70
+ <app> state 72
+ state 70: #12
+ <var> state 71
+ state 71: #12
+ state 72: #11 #12 #13
+ <var> state 73
+ % state 76
+ state 73: #12
+ <var> state 74
+ state 74: #12
+ <var> state 75
+ state 75: #12
+ state 76: #11 #12 #13
+ <var> state 77
+ state 77: #11 #12 #13
+ <var> state 78
+ state 78: #11 #12 #13
+}
+{
+ rule #0: x::int==y::int = x==y
+ rule #1: x::double==y::double = x==y
+ rule #2: x::int==y::double = x==y
+ rule #3: x::double==y::int = x==y
+ rule #4: x::bigint==y::bigint = bigint_cmp x y==0
+ rule #5: x::int==y::bigint = bigint x==y
+ rule #6: x::bigint==y::int = x==bigint y
+ rule #7: x::bigint==y::double = double x==y
+ rule #8: x::double==y::bigint = x==double y
+ rule #9: x==y = bigint x==bigint y
+ rule #10: x::string==y::string = strcmp x y==0
+ rule #11: ()==() = 1
+ rule #12: (x,xs)==() = 0
+ rule #13: ()==(x,xs) = 0
+ rule #14: (x,xs)==(y,ys) = if x==y then xs==ys else 0
+ rule #15: []==[] = 1
+ rule #16: x:xs==[] = 0
+ rule #17: []==x:xs = 0
+ rule #18: x:xs==y:ys = if x==y then xs==ys else 0
+ rule #19: x1+:y1==x2+:y2 = x1==x2&&y1==y2
+ rule #20: r1<:t1==r2<:t2 = r1==r2&&t1==t2
+ rule #21: z1@(_+:_)==z2@(_<:_) = z1==rect z2
+ rule #22: z1@(_<:_)==z2@(_+:_) = rect z1==z2
+ rule #23: x1+:y1==x2 = x1==x2&&y1==0
+ rule #24: x1==x2+:y2 = x1==x2&&y2==0
+ rule #25: z1@(r1<:t1)==x2 = z1==x2<:0
+ rule #26: x1==z2@(r2<:t2) = x1<:0==z2
+ rule #27: x1%y1==x2%y2 = x1*y2==x2*y1
+ rule #28: x1%y1==x2 = x1==x2*y1
+ rule #29: x1==x2%y2 = x1*y2==x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13 #14 #15 #16 #17 #18 #19 #20 #21 #22 #23 #24 #25 #26 #27 #28 #29
+ <var> state 1
+ <var>::int state 13
+ <var>::bigint state 28
+ <var>::double state 43
+ <var>::string state 58
+ <var> state 71
+ [] state 84
+ () state 100
+ <app> state 116
+ state 1: #24 #26 #29
+ <app> state 2
+ state 2: #24 #26 #29
+ <app> state 3
+ state 3: #24 #26 #29
+ +: state 4
+ <: state 7
+ % state 10
+ state 4: #24
+ <var> state 5
+ state 5: #24
+ <var> state 6
+ state 6: #24
+ state 7: #26
+ <var> state 8
+ state 8: #26
+ <var> state 9
+ state 9: #26
+ state 10: #29
+ <var> state 11
+ state 11: #29
+ <var> state 12
+ state 12: #29
+ state 13: #0 #2 #5 #24 #26 #29
+ <var>::int state 14
+ <var>::bigint state 15
+ <var>::double state 16
+ <app> state 17
+ state 14: #0
+ state 15: #5
+ state 16: #2
+ state 17: #24 #26 #29
+ <app> state 18
+ state 18: #24 #26 #29
+ +: state 19
+ <: state 22
+ % state 25
+ state 19: #24
+ <var> state 20
+ state 20: #24
+ <var> state 21
+ state 21: #24
+ state 22: #26
+ <var> state 23
+ state 23: #26
+ <var> state 24
+ state 24: #26
+ state 25: #29
+ <var> state 26
+ state 26: #29
+ <var> state 27
+ state 27: #29
+ state 28: #4 #6 #7 #24 #26 #29
+ <var>::int state 29
+ <var>::bigint state 30
+ <var>::double state 31
+ <app> state 32
+ state 29: #6
+ state 30: #4
+ state 31: #7
+ state 32: #24 #26 #29
+ <app> state 33
+ state 33: #24 #26 #29
+ +: state 34
+ <: state 37
+ % state 40
+ state 34: #24
+ <var> state 35
+ state 35: #24
+ <var> state 36
+ state 36: #24
+ state 37: #26
+ <var> state 38
+ state 38: #26
+ <var> state 39
+ state 39: #26
+ state 40: #29
+ <var> state 41
+ state 41: #29
+ <var> state 42
+ state 42: #29
+ state 43: #1 #3 #8 #24 #26 #29
+ <var>::int state 44
+ <var>::bigint state 45
+ <var>::double state 46
+ <app> state 47
+ state 44: #3
+ state 45: #8
+ state 46: #1
+ state 47: #24 #26 #29
+ <app> state 48
+ state 48: #24 #26 #29
+ +: state 49
+ <: state 52
+ % state 55
+ state 49: #24
+ <var> state 50
+ state 50: #24
+ <var> state 51
+ state 51: #24
+ state 52: #26
+ <var> state 53
+ state 53: #26
+ <var> state 54
+ state 54: #26
+ state 55: #29
+ <var> state 56
+ state 56: #29
+ <var> state 57
+ state 57: #29
+ state 58: #10 #24 #26 #29
+ <var>::string state 59
+ <app> state 60
+ state 59: #10
+ state 60: #24 #26 #29
+ <app> state 61
+ state 61: #24 #26 #29
+ +: state 62
+ <: state 65
+ % state 68
+ state 62: #24
+ <var> state 63
+ state 63: #24
+ <var> state 64
+ state 64: #24
+ state 65: #26
+ <var> state 66
+ state 66: #26
+ <var> state 67
+ state 67: #26
+ state 68: #29
+ <var> state 69
+ state 69: #29
+ <var> state 70
+ state 70: #29
+ state 71: #9 #24 #26 #29
+ <var> state 72
+ <app> state 73
+ state 72: #9
+ state 73: #24 #26 #29
+ <app> state 74
+ state 74: #24 #26 #29
+ +: state 75
+ <: state 78
+ % state 81
+ state 75: #24
+ <var> state 76
+ state 76: #24
+ <var> state 77
+ state 77: #24
+ state 78: #26
+ <var> state 79
+ state 79: #26
+ <var> state 80
+ state 80: #26
+ state 81: #29
+ <var> state 82
+ state 82: #29
+ <var> state 83
+ state 83: #29
+ state 84: #15 #17 #24 #26 #29
+ [] state 85
+ <app> state 86
+ state 85: #15
+ state 86: #17 #24 #26 #29
+ <app> state 87
+ state 87: #17 #24 #26 #29
+ : state 88
+ +: state 91
+ <: state 94
+ % state 97
+ state 88: #17
+ <var> state 89
+ state 89: #17
+ <var> state 90
+ state 90: #17
+ state 91: #24
+ <var> state 92
+ state 92: #24
+ <var> state 93
+ state 93: #24
+ state 94: #26
+ <var> state 95
+ state 95: #26
+ <var> state 96
+ state 96: #26
+ state 97: #29
+ <var> state 98
+ state 98: #29
+ <var> state 99
+ state 99: #29
+ state 100: #11 #13 #24 #26 #29
+ () state 101
+ <app> state 102
+ state 101: #11
+ state 102: #13 #24 #26 #29
+ <app> state 103
+ state 103: #13 #24 #26 #29
+ , state 104
+ +: state 107
+ <: state 110
+ % state 113
+ state 104: #13
+ <var> state 105
+ state 105: #13
+ <var> state 106
+ state 106: #13
+ state 107: #24
+ <var> state 108
+ state 108: #24
+ <var> state 109
+ state 109: #24
+ state 110: #26
+ <var> state 111
+ state 111: #26
+ <var> state 112
+ state 112: #26
+ state 113: #29
+ <var> state 114
+ state 114: #29
+ <var> state 115
+ state 115: #29
+ state 116: #12 #14 #16 #18 #19 #20 #21 #22 #23 #24 #25 #26 #27 #28 #29
+ <var> state 117
+ <app> state 130
+ state 117: #24 #26 #29
+ <var> state 118
+ state 118: #24 #26 #29
+ <app> state 119
+ state 119: #24 #26 #29
+ <app> state 120
+ state 120: #24 #26 #29
+ +: state 121
+ <: state 124
+ % state 127
+ state 121: #24
+ <var> state 122
+ state 122: #24
+ <var> state 123
+ state 123: #24
+ state 124: #26
+ <var> state 125
+ state 125: #26
+ <var> state 126
+ state 126: #26
+ state 127: #29
+ <var> state 128
+ state 128: #29
+ <var> state 129
+ state 129: #29
+ state 130: #12 #14 #16 #18 #19 #20 #21 #22 #23 #24 #25 #26 #27 #28 #29
+ <var> state 131
+ , state 145
+ : state 163
+ +: state 181
+ <: state 201
+ % state 221
+ state 131: #24 #26 #29
+ <var> state 132
+ state 132: #24 #26 #29
+ <var> state 133
+ state 133: #24 #26 #29
+ <app> state 134
+ state 134: #24 #26 #29
+ <app> state 135
+ state 135: #24 #26 #29
+ +: state 136
+ <: state 139
+ % state 142
+ state 136: #24
+ <var> state 137
+ state 137: #24
+ <var> state 138
+ state 138: #24
+ state 139: #26
+ <var> state 140
+ state 140: #26
+ <var> state 141
+ state 141: #26
+ state 142: #29
+ <var> state 143
+ state 143: #29
+ <var> state 144
+ state 144: #29
+ state 145: #12 #14 #24 #26 #29
+ <var> state 146
+ state 146: #12 #14 #24 #26 #29
+ <var> state 147
+ state 147: #12 #14 #24 #26 #29
+ () state 148
+ <app> state 149
+ state 148: #12
+ state 149: #14 #24 #26 #29
+ <app> state 150
+ state 150: #14 #24 #26 #29
+ , state 151
+ +: state 154
+ <: state 157
+ % state 160
+ state 151: #14
+ <var> state 152
+ state 152: #14
+ <var> state 153
+ state 153: #14
+ state 154: #24
+ <var> state 155
+ state 155: #24
+ <var> state 156
+ state 156: #24
+ state 157: #26
+ <var> state 158
+ state 158: #26
+ <var> state 159
+ state 159: #26
+ state 160: #29
+ <var> state 161
+ state 161: #29
+ <var> state 162
+ state 162: #29
+ state 163: #16 #18 #24 #26 #29
+ <var> state 164
+ state 164: #16 #18 #24 #26 #29
+ <var> state 165
+ state 165: #16 #18 #24 #26 #29
+ [] state 166
+ <app> state 167
+ state 166: #16
+ state 167: #18 #24 #26 #29
+ <app> state 168
+ state 168: #18 #24 #26 #29
+ : state 169
+ +: state 172
+ <: state 175
+ % state 178
+ state 169: #18
+ <var> state 170
+ state 170: #18
+ <var> state 171
+ state 171: #18
+ state 172: #24
+ <var> state 173
+ state 173: #24
+ <var> state 174
+ state 174: #24
+ state 175: #26
+ <var> state 176
+ state 176: #26
+ <var> state 177
+ state 177: #26
+ state 178: #29
+ <var> state 179
+ state 179: #29
+ <var> state 180
+ state 180: #29
+ state 181: #19 #21 #23 #24 #26 #29
+ <var> state 182
+ state 182: #19 #21 #23 #24 #26 #29
+ <var> state 183
+ state 183: #19 #21 #23 #24 #26 #29
+ <var> state 184
+ <app> state 185
+ state 184: #23
+ state 185: #19 #21 #23 #24 #26 #29
+ <var> state 186
+ <app> state 188
+ state 186: #23
+ <var> state 187
+ state 187: #23
+ state 188: #19 #21 #23 #24 #26 #29
+ <var> state 189
+ +: state 192
+ <: state 195
+ % state 198
+ state 189: #23
+ <var> state 190
+ state 190: #23
+ <var> state 191
+ state 191: #23
+ state 192: #19 #23 #24
+ <var> state 193
+ state 193: #19 #23 #24
+ <var> state 194
+ state 194: #19 #23 #24
+ state 195: #21 #23 #26
+ <var> state 196
+ state 196: #21 #23 #26
+ <var> state 197
+ state 197: #21 #23 #26
+ state 198: #23 #29
+ <var> state 199
+ state 199: #23 #29
+ <var> state 200
+ state 200: #23 #29
+ state 201: #20 #22 #24 #25 #26 #29
+ <var> state 202
+ state 202: #20 #22 #24 #25 #26 #29
+ <var> state 203
+ state 203: #20 #22 #24 #25 #26 #29
+ <var> state 204
+ <app> state 205
+ state 204: #25
+ state 205: #20 #22 #24 #25 #26 #29
+ <var> state 206
+ <app> state 208
+ state 206: #25
+ <var> state 207
+ state 207: #25
+ state 208: #20 #22 #24 #25 #26 #29
+ <var> state 209
+ +: state 212
+ <: state 215
+ % state 218
+ state 209: #25
+ <var> state 210
+ state 210: #25
+ <var> state 211
+ state 211: #25
+ state 212: #22 #24 #25
+ <var> state 213
+ state 213: #22 #24 #25
+ <var> state 214
+ state 214: #22 #24 #25
+ state 215: #20 #25 #26
+ <var> state 216
+ state 216: #20 #25 #26
+ <var> state 217
+ state 217: #20 #25 #26
+ state 218: #25 #29
+ <var> state 219
+ state 219: #25 #29
+ <var> state 220
+ state 220: #25 #29
+ state 221: #24 #26 #27 #28 #29
+ <var> state 222
+ state 222: #24 #26 #27 #28 #29
+ <var> state 223
+ state 223: #24 #26 #27 #28 #29
+ <var> state 224
+ <app> state 225
+ state 224: #28
+ state 225: #24 #26 #27 #28 #29
+ <var> state 226
+ <app> state 228
+ state 226: #28
+ <var> state 227
+ state 227: #28
+ state 228: #24 #26 #27 #28 #29
+ <var> state 229
+ +: state 232
+ <: state 235
+ % state 238
+ state 229: #28
+ <var> state 230
+ state 230: #28
+ <var> state 231
+ state 231: #28
+ state 232: #24 #28
+ <var> state 233
+ state 233: #24 #28
+ <var> state 234
+ state 234: #24 #28
+ state 235: #26 #28
+ <var> state 236
+ state 236: #26 #28
+ <var> state 237
+ state 237: #26 #28
+ state 238: #27 #28 #29
+ <var> state 239
+ state 239: #27 #28 #29
+ <var> state 240
+ state 240: #27 #28 #29
+}
+{
+ rule #0: x::int!=y::int = x!=y
+ rule #1: x::double!=y::double = x!=y
+ rule #2: x::int!=y::double = x!=y
+ rule #3: x::double!=y::int = x!=y
+ rule #4: x::bigint!=y::bigint = bigint_cmp x y!=0
+ rule #5: x::int!=y::bigint = bigint x!=y
+ rule #6: x::bigint!=y::int = x!=bigint y
+ rule #7: x::bigint!=y::double = double x!=y
+ rule #8: x::double!=y::bigint = x!=double y
+ rule #9: x!=y = bigint x!=bigint y
+ rule #10: x::string!=y::string = strcmp x y!=0
+ rule #11: ()!=() = 0
+ rule #12: (x,xs)!=() = 1
+ rule #13: ()!=(x,xs) = 1
+ rule #14: (x,xs)!=(y,ys) = if x!=y then 1 else xs!=ys
+ rule #15: []!=[] = 0
+ rule #16: x:xs!=[] = 1
+ rule #17: []!=x:xs = 1
+ rule #18: x:xs!=y:ys = if x!=y then 1 else xs!=ys
+ rule #19: x1+:y1!=x2+:y2 = x1!=x2||y1!=y2
+ rule #20: r1<:t1!=r2<:t2 = r1!=r2||t1!=t2
+ rule #21: z1@(_+:_)!=z2@(_<:_) = z1!=rect z2
+ rule #22: z1@(_<:_)!=z2@(_+:_) = rect z1!=z2
+ rule #23: x1+:y1!=x2 = x1!=x2||y1!=0
+ rule #24: x1!=x2+:y2 = x1!=x2||y2!=0
+ rule #25: z1@(r1<:t1)!=x2 = z1!=x2<:0
+ rule #26: x1!=z2@(r2<:t2) = x1<:0!=z2
+ rule #27: x1%y1!=x2%y2 = x1*y2!=x2*y1
+ rule #28: x1%y1!=x2 = x1!=x2*y1
+ rule #29: x1!=x2%y2 = x1*y2!=x2
+ state 0: #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13 #14 #15 #16 #17 #18 #19 #20 #21 #22 #23 #24 #25 #26 #27 #28 #29
+ <var> state 1
+ <var>::int state 13
+ <var>::bigint state 28
+ <var>::double state 43
+ <var>::string state 58
+ <var> state 71
+ [] state 84
+ () state 100
+ <app> state 116
+ state 1: #24 #26 #29
+ <app> state 2
+ state 2: #24 #26 #29
+ <app> state 3
+ state 3: #24 #26 #29
+ +: state 4
+ <: state 7
+ % state 10
+ state 4: #24
+ <var> state 5
+ state 5: #24
+ <var> state 6
+ state 6: #24
+ state 7: #26
+ <var> state 8
+ state 8: #26
+ <var> state 9
+ state 9: #26
+ state 10: #29
+ <var> state 11
+ state 11: #29
+ <var> state 12
+ state 12: #29
+ state 13: #0 #2 #5 #24 #26 #29
+ <var>::int state 14
+ <var>::bigint state 15
+ <var>::double state 16
+ <app> state 17
+ state 14: #0
+ state 15: #5
+ state 16: #2
+ state 17: #24 #26 #29
+ <app> state 18
+ state 18: #24 #26 #29
+ +: state 19
+ <: state 22
+ % state 25
+ state 19: #24
+ <var> state 20
+ state 20: #24
+ <var> state 21
+ state 21: #24
+ state 22: ...
[truncated message content] |
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X