some further beautify

Author: CrescentonC

hkmc2/shared/src/test/mlscript/nofib/NofibPrelude.mls

@@ -60,7 +60,7 @@ class Tup6[out T1, T2, T3, T4, T5, T6](fst: T1, snd: T2, thd: T3, fth: T4, ffth:
 class Tup7[out T1, T2, T3, T4, T5, T6, T7](fst: T1, snd: T2, thd: T3, fth: T4, ffth: T5, sxth: T6, svth: T7)
 class Tup8[out T1, T2, T3, T4, T5, T6, T7, T8](fst: T1, snd: T2, thd: T3, fth: T4, ffth: T5, sxth: T6, svth: T7, eghth: T8)
 
-fun (.) compose(f, g) = x => f(g(x))
+fun compose(f, g) = x => f(g(x))
 
 fun snd(x) = if x is Tup2(f, s) then s
 fun fst(x) = if x is Tup2(f, s) then f
@@ -76,7 +76,7 @@ fun power(a, n) = globalThis.Math.pow(a, n)
 fun intDiv(a, b) = globalThis.Math.floor(a / b)
 fun intQuot(a, b) = globalThis.Math.trunc(a / b)
 
-fun (%) intMod(a, b) = a - (b * intDiv(a, b))
+fun intMod(a, b) = a - (b * intDiv(a, b))
 fun intRem(a, b) = a - (b * intQuot(a, b))
 
 fun quotRem(a, b) = Tup2(intQuot(a, b), intRem(a, b))
@@ -138,7 +138,7 @@ fun inList(x, ls) = if ls is
 
 fun notElem(x, ls) = not(inList(x, ls))
 
-fun (++) append(xs, ys) = if xs is
+fun append(xs, ys) = if xs is
   Nil then ys
   Cons(x, xs) then Cons(x, append(xs, ys))
 

hkmc2/shared/src/test/mlscript/nofib/atom.mls

@@ -1,6 +1,6 @@
 :js
 :import NofibPrelude.mls
-//│ Imported 112 member(s)
+//│ Imported 109 member(s)
 
 
 class State(position: List[Num], velocity: List[Num])

hkmc2/shared/src/test/mlscript/nofib/awards.mls

@@ -1,6 +1,6 @@
 :js
 :import NofibPrelude.mls
-//│ Imported 112 member(s)
+//│ Imported 109 member(s)
 
 
 fun delete_(xs, e) = deleteBy((x, y) => x == y, e, xs)
@@ -41,10 +41,13 @@ fun perms(m, nns) = if
 
 fun awards(scores) =
   let sumscores = map(p => Tup2(sum(p), p), perms(3, scores))
+  
   fun atleast(threshold) =
     filter(sum_p => if sum_p is Tup2(sum_, p) then sum_ >= threshold, sumscores)
+  
   fun award(name_threshold) = if name_threshold is Tup2(name, threshold) then
     map(ps => Tup2(name, ps), sort(atleast(threshold)))
+  
   append(append(award(Tup2("Gold", 70)), award(Tup2("Silver", 60))), award(Tup2("Bronze", 50)))
 
 fun findawards(scores) = if awards(scores) is
@@ -62,7 +65,7 @@ fun competitors(i) =
   Tup2("Kevin", 9::23::17::54::i::41::9::18::14::Nil) :: Nil
 
 fun testAwards_nofib(n) =
-  map(x => nofibPrint(findallawards(competitors(x % 100)).toString()), enumFromTo(1, n))
+  map(x => nofibPrint(findallawards(competitors(intMod(x, 100))).toString()), enumFromTo(1, n))
 
 
 // NOTE: original input 1000

hkmc2/shared/src/test/mlscript/nofib/banner.mls

@@ -1,6 +1,6 @@
 :js
 :import NofibPrelude.mls
-//│ Imported 112 member(s)
+//│ Imported 109 member(s)
 
 
 let blank =
@@ -128,11 +128,13 @@ fun isSpace(c) =
   (n == 32)
 
 fun picChar(c) =
+  
   fun lscomp(ls) = if ls is
     Nil then Nil
     Cons(h, t) and
       h is Tup2(c_, letter) and c_ === c then Cons(letter, lscomp(t))
       else lscomp(t)
+  
   if
     isUpper(c) then atIndex(int_of_char(c) - int_of_char("A"), alphas)
     isLower(c) then atIndex(int_of_char(c) - int_of_char("a"), alphas)

hkmc2/shared/src/test/mlscript/nofib/boyer.mls

@@ -1,6 +1,6 @@
 :js
 :import NofibPrelude.mls
-//│ Imported 112 member(s)
+//│ Imported 109 member(s)
 
 
 abstract class Id: A | B | C | D | X | Y | Z | U | W | ADD1 | AND | APPEND | CONS | CONSP | DIFFERENCE | DIVIDES | EQUAL | EVEN | EXP | F | FALSE | FOUR | GCD | GREATEREQP | GREATERP | IF | IFF | IMPLIES | LENGTH | LESSEQP | LESSP | LISTP | MEMBER | NIL | NILP | NLISTP | NOT | ODD | ONE | OR | PLUS | QUOTIENT | REMAINDER | REVERSE | SUB1 | TIMES | TRUE | TWO | ZERO | ZEROP
@@ -165,76 +165,116 @@ fun test0(xxxx) =
   let nil =        Fun(NIL  , Nil, lazy of () => Nil)
   let boyerTrue =  Fun(TRUE , Nil, lazy of () => Nil)
   let zero    =    Fun(ZERO , Nil, lazy of () => Nil)
+  
   fun one()   =    Fun(ONE, Nil, lazy of () => Cons(Tup2(one(), add1(zero)), Nil))
+  
   fun two()   =    Fun(TWO, Nil, lazy of () => Cons(Tup2(two(), add1(one())), Nil))
+  
   fun four()  =   Fun(FOUR, Nil, lazy of () => Cons(Tup2(four(), add1(add1(two()))), Nil))
+  
   fun add1(a) =   Fun(ADD1, a :: Nil, lazy of () => Nil)
+  
   fun if_(a, b, c) = Fun(IF, Cons(a, Cons(b, Cons(c, Nil))), lazy of () => Cons(Tup2(if_(if_(x, y, z), u, w), if_(x, if_(y, u, w), if_(z, u, w))), Nil))
+  
   fun not_(a) = Fun(NOT, a :: Nil, lazy of () => Tup2(not_(x), if_(x, boyerFalse, boyerTrue)) :: Nil)
+  
   fun and_(a, b) =
     Fun(AND, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(and_(x, y), if_(x, if_(y, boyerTrue, boyerFalse), boyerFalse)), Nil))
+  
   fun append_(a, b) =
     Fun(APPEND, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(append_(append_(x, y), z), append_(x, append_(y, z))), Nil))
+  
   fun cons(a, b) =
     Fun(CONS, Cons(a, Cons(b, Nil)), lazy of () => Nil)
+  
   fun consp(a) =
     Fun(CONSP, Cons(a, Nil), lazy of () => Cons(Tup2(consp(cons(x, y)), boyerTrue), Nil))
+  
   fun difference(a, b) =
     Fun(DIFFERENCE, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(difference(x, x), zero), Cons(Tup2(difference(plus(x, y), x), y), Cons(Tup2(difference(plus(y, x), x), y), Cons(Tup2(difference(plus(x, y), plus(x, z)), difference(y, z)), Cons(Tup2(difference(plus(y, plus(x, z)), x), plus(y, z)), Cons(Tup2(difference(add1(plus(y, z)), z), add1(y)), Cons(Tup2(difference(add1(add1(x)), two()), x), Nil))))))))
+  
   fun divides(a, b) =
     Fun(DIVIDES, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(divides(x, y), zerop(remainder(y, x))), Nil))
+  
   fun equal(a, b) =
     Fun(EQUAL, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(equal(plus(x, y), zero), and_(zerop(x), zerop(y))), Cons(Tup2(equal(plus(x, y), plus(x, z)), equal(y, z)), Cons(Tup2(equal(zero, difference(x, y)), not_(lessp(y, x))), Cons(Tup2(equal(x, difference(x, y)), or_(equal(x, zero), zerop(y))), Cons(Tup2(equal(times(x, y), zero), or_(zerop(x), zerop(y))), Cons(Tup2(equal(append_(x, y), append_(x, z)), equal(y, z)), Cons(Tup2(equal(y, times(x, y)), or_(equal(y, zero), equal(x, one()))), Cons(Tup2(equal(x, times(x, y)), or_(equal(x, zero), equal(y, one()))), Cons(Tup2(equal(times(x, y), one()), and_(equal(x, one()), equal(y, one()))), Cons(Tup2(equal(difference(x, y), difference(z, y)), if_(lessp(x, y), not_(lessp(y, z)), if_(lessp(z, y), not_(lessp(y, x)), equal(x, z)))), Cons(Tup2(equal(lessp(x, y), z), if_(lessp(x, y), equal(boyerTrue, z), equal(boyerFalse, z))), Nil))))))))))))
+  
   fun even_(a) =
     Fun(EVEN, Cons(a, Nil), lazy of () => Cons(Tup2(even_(x), if_(zerop(x), boyerTrue, odd_(sub1(x)))), Nil))
+  
   fun exp_(a, b) =
     Fun(EXP, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(exp_(x, plus(y, z)), times(exp_(x, y), exp_(x, z))), Cons(Tup2(exp_(x, times(y, z)), exp_(exp_(x, y), z)), Nil)))
+  
   fun f(a) =
     Fun(F, Cons(a, Nil), lazy of () => Nil)
+  
   fun gcd_(a, b) =
     Fun(GCD, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(gcd_(x, y), gcd_(y, x)), Cons(Tup2(gcd_(times(x, z), times(y, z)), times(z, gcd_(x, y))), Nil)))
+  
   fun greatereqp(a, b) =
     Fun(GREATEREQP, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(greatereqp(x, y), not_(lessp(x, y))), Nil))
+  
   fun greaterp(a, b) =
     Fun(GREATERP, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(greaterp(x, y), lessp(y, x)), Nil))
+  
   fun implies(a, b) =
     Fun(IMPLIES, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(implies(x, y), if_(x, if_(y, boyerTrue, boyerFalse), boyerTrue)), Nil))
+  
   fun iff(a, b) =
     Fun(IFF, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(iff(x, y), and_(implies(x, y), implies(y, x))), Nil))
+  
   fun length_(a) =
     Fun(LENGTH, Cons(a, Nil), lazy of () => Cons(Tup2(length_(reverse_(x)), length_(x)), Cons(Tup2(length_(cons(x, cons(y, cons(z, cons(u, w))))), plus(four(), length_(w))), Nil)))
+  
   fun lesseqp(a, b) =
     Fun(LESSEQP, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(lesseqp(x, y), not_(lessp(y, x))), Nil))
+  
   fun lessp(a, b) =
     Fun(LESSP, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(lessp(remainder(x, y), y), not_(zerop(y))), Cons(Tup2(lessp(quotient(x, y), x), and_(not_(zerop(x)), lessp(one(), y))), Cons(Tup2(lessp(plus(x, y), plus(x, z)), lessp(y, z)), Cons(Tup2(lessp(times(x, z), times(y, z)), and_(not_(zerop(z)), lessp(x, y))), Cons(Tup2(lessp(y, plus(x, y)), not_(zerop(x))), Nil))))))
+  
   fun nilp(a) =
     Fun(NILP, Cons(a, Nil), lazy of () => Cons(Tup2(nilp(x), equal(x, nil)), Nil))
+  
   fun listp(a) =
     Fun(LISTP, Cons(a, Nil), lazy of () => Cons(Tup2(listp(x), or_(nilp(x), consp(x))), Nil))
+  
   fun member(a, b) =
     Fun(MEMBER, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(member(x, append_(y, z)), or_(member(x, y), member(x, z))), Cons(Tup2(member(x, reverse_(y)), member(x, y)), Nil)))
+  
   fun nlistp(a) =
     Fun(NLISTP, Cons(a, Nil), lazy of () => Cons(Tup2(nlistp(x), not_(listp(x))), Nil))
+  
   fun odd_(a) =
     Fun(ODD, Cons(a, Nil), lazy of () => Cons(Tup2(odd_(x), even_(sub1(x))), Nil))
+  
   fun or_(a, b) =
     Fun(OR, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(or_(x, y), if_(x, boyerTrue, if_(y, boyerTrue, boyerFalse))), Nil))
+  
   fun plus(a, b) =
     Fun(PLUS, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(plus(plus(x, y), z), plus(x, plus(y, z))), Cons(Tup2(plus(remainder(x, y), times(y, quotient(x, y))), x), Cons(Tup2(plus(x, add1(y)), add1(plus(x, y))), Nil))))
+  
   fun quotient(a, b) =
     Fun(QUOTIENT, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(quotient(plus(x, plus(x, y)), two()), plus(x, quotient(y, two()))), Cons(Tup2(quotient(times(y, x), y), if_(zerop(y), zero, x)), Nil)))
+  
   fun remainder(a, b) =
     Fun(REMAINDER, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(remainder(x, one()), zero), Cons(Tup2(remainder(x, x), zero), Cons(Tup2(remainder(times(x, y), x), zero), Cons(Tup2(remainder(times(x, y), y), zero), Nil)))))
+  
   fun reverse_(a) =
     Fun(REVERSE, Cons(a, Nil), lazy of () => Cons(Tup2(reverse_(append_(x, y)), append_(reverse_(y), reverse_(x))), Nil))
+  
   fun sub1(a) =
     Fun(SUB1, Cons(a, Nil), lazy of () => Cons(Tup2(sub1(add1(x)), x), Nil))
+  
   fun times(a, b) =
     Fun(TIMES, Cons(a, Cons(b, Nil)), lazy of () => Cons(Tup2(times(x, plus(y, z)), plus(times(x, y), times(x, z))), Cons(Tup2(times(times(x, y), z), times(x, times(y, z))), Cons(Tup2(times(x, difference(y, z)), difference(times(y, x), times(z, x))), Cons(Tup2(times(x, add1(y)), plus(x, times(x, y))), Nil)))))
+  
   fun zerop(a) =
     Fun(ZEROP, Cons(a, Nil), lazy of () => Cons(Tup2(zerop(x), equal(x, zero)), Nil))
+  
   let subst0 = Cons(Tup2(X, f(plus(plus(a, b), plus(c, zero)))), Cons(Tup2(Y, f(times(times(a, b), plus(c, d)))), Cons(Tup2(Z, f(reverse_(append_(append_(a, b), nil)))), Cons(Tup2(U, equal(plus(a, b), difference(x, y))), Cons(Tup2(W, lessp(remainder(a, b), member(a, length_(b)))), Nil)))))
+  
   let theorem = implies(and_(implies(xxxx, y), and_(implies(y, z), and_(implies(z, u), implies(u, w)))), implies(x, w))
+  
   tautp(apply_subst(subst0, theorem))
 
 fun testBoyer_nofib(n) = all(test0, replicate(n, Var(X)))

hkmc2/shared/src/test/mlscript/nofib/calendar.mls

@@ -1,6 +1,6 @@
 :js
 :import NofibPrelude.mls
-//│ Imported 112 member(s)
+//│ Imported 109 member(s)
 
 
 fun unlines(ls) = concat(map(x => append(x, ("\n" :: Nil)), ls))
@@ -79,6 +79,7 @@ fun cal(year) =
   fun table(fd, ml) = append(daynames, entries(fd, ml))
   fun entries(fd, ml) = block(7, dates(fd, ml))
   fun months(yer) = zip3(monthNames, firstDays(yer), monthLengths(yer))
+  
   unlines(append(banner(year), body(year)))
 
 fun testCalendar_nofib(n) = map(x => cal(x), enumFromTo(1993, 1993 + n))