Update concat operator

lib/std/num/ddouble.kk

@@ -207,16 +207,16 @@ fun ddouble-int-exp( i : int, e : int ) : ddouble
     val py   = px - 14
     if py <= 0 then
       // if 28 or less digits we can convert with two doubles
-      // trace("ddouble-i: " + i.show + ", hi:" + hi.show + ",  lo: " + y.show)
+      // trace("ddouble-i: " ++ i.show ++ ", hi:" ++ hi.show ++ ",  lo: " ++ y.show)
       small-exp(hi, px + e) + small-exp( y, e)
 
     else
       // otherwise use 2 initial 14 digits and a trailing value
       val (mid,z) = y.cdivmod-exp10(py)
       val pz = py - 14
       val (lo,plo) = if pz <= 0 then (z,0) else (z.cdiv-exp10(pz), pz)
-      //trace("ddouble-i: " + i.show + ", hi:" + hi.show + ", mid: " + mid.show + ", lo: " + lo.show)
-      //trace("  px: " + px.show + ", py : " + py.show + ", plo: " + plo.show + ", e: " + e.show )
+      //trace("ddouble-i: " ++ i.show ++ ", hi:" ++ hi.show ++ ", mid: " ++ mid.show ++ ", lo: " ++ lo.show)
+      //trace("  px: " ++ px.show ++ ", py : " ++ py.show ++ ", plo: " ++ plo.show ++ ", e: " ++ e.show )
       small-exp( hi, px + e) + (small-exp( mid, py + e) + small-exp( lo, plo + e))
 
 
@@ -750,7 +750,7 @@ pub fun parse-ddouble( s  : string ) : maybe<ddouble>
       val w	= (whole + frac).parse-int.default(0)
       val e	= exp - frac.count
       val x	= ddouble-int-exp(w,e)
-      // trace("parse: s: " + s + "\n  w: " + w.show + ", e: " + e.show + "\n  wx: " + w.ddouble.show-sum + ", x: " + x.show + "\n  " + x.show-sum)
+      // trace("parse: s: " ++ s ++ "\n  w: " ++ w.show ++ ", e: " ++ e.show ++ "\n  wx: " ++ w.ddouble.show-sum ++ ", x: " ++ x.show ++ "\n  " ++ x.show-sum)
       Just(x)
 
     Nothing -> match(t.find(rx-special))
@@ -799,7 +799,7 @@ fun pddouble-normal() : parse ddouble
   val w = ((if neg then "-" else "") ++ whole ++ frac).parse-int.default(0)
   val e = exp - frac.count
   val x = ddouble-int-exp(w,e)
-  // trace("parse-normal: w: " + w.show + ", e: " ++ e.show ++ "\n  wx: " ++ w.ddouble.show-sum ++ ", x: " ++ x.show ++ "\n  " ++ x.show-sum)
+  // trace("parse-normal: w: " ++ w.show ++ ", e: " ++ e.show ++ "\n  wx: " ++ w.ddouble.show-sum ++ ", x: " ++ x.show ++ "\n  " ++ x.show-sum)
   x
 
 /*------------------------------------------------------

lib/std/num/decimal.kk

@@ -43,7 +43,7 @@ fun decimal-exp( i : int, exp : int = 0 ) : decimal
   // use exponents only at specific intervals to avoid too much re-scaling
   val x = round-exp(exp)  // always x <= exp
   val diff = exp - x
-  // trace("decimal-exp: " + i.show + "e" + exp.show + ", diff: " + diff.show + ", x: " + x.show)
+  // trace("decimal-exp: " ++ i.show ++ "e" ++ exp.show ++ ", diff: " ++ diff.show ++ ", x: " ++ x.show)
   if diff.is-zero then Decimal(i,exp) else Decimal(i.mul-exp10(diff.abs),x)
 
 /* Create a decimal from a `:float64` with a specified maximal precision (=`-1`).
@@ -95,7 +95,7 @@ fun pdecimal() : parse decimal
   val whole = digits()
   val frac = optional("", { char('.'); digits() })
   val exp  = optional(0, { one-of("eE"); pint() })
-  // trace("frac:" + frac)
+  // trace("frac:" ++ frac)
   val i = decimal-exp( (whole ++ frac).parse-int-default(0), exp - frac.count )
   if neg then ~i else i
 
@@ -117,10 +117,10 @@ pub fun reduce( x : decimal ) : decimal
 // Add two decimals.
 pub fun (+)( x : decimal, y : decimal ) : decimal
   val e  = min(x.exp,y.exp)
-  // trace("add: " ++ x.show-raw ++ " + " ++ y.show-raw ++ ", using exp: " ++ e.show )
+  // trace("add: " ++ x.show-raw ++ " ++ " ++ y.show-raw ++ ", using exp: " ++ e.show )
   val xx = x.expand(e)
   val yy = y.expand(e)
-  // trace("expanded add: " ++ xx.show-raw ++ " + " ++ yy.show-raw)
+  // trace("expanded add: " ++ xx.show-raw ++ " ++ " ++ yy.show-raw)
   Decimal(xx.num + yy.num, e)
 
 // Negate a decimal.
@@ -233,7 +233,7 @@ pub fun round-to-prec( x : decimal, prec : int = 0, rnd : round = Half-even ) :
     Truncate  -> if !q.is-neg then q else q.inc
     Away-from-zero  -> if !q.is-pos then q else q.inc
 
-  //trace("round: " + x.showx + ", q: " + q.show + ", r: " + r.show + ", q1: " + q1.show + "e-" + prec.show )
+  //trace("round: " ++ x.showx ++ ", q: " ++ q.show ++ ", r: " ++ r.show ++ ", q1: " ++ q1.show ++ "e-" ++ prec.show )
   decimal-exp(q1,~prec)
 
 // Optimize: Use float64 division when within precision bounds.

lib/std/os/env.kk

@@ -9,7 +9,7 @@
 /*
 Access to the program environment and commmand line arguments.
 
-Print the environment: `get-env().map(fn(p) { p.fst + "=" + p.snd }).join("\n").print`
+Print the environment: `get-env().map(fn(p) { p.fst ++ "=" ++ p.snd }).join("\n").print`
 */
 module std/os/env
 

lib/std/time/instant.kk

@@ -104,7 +104,7 @@ fun convert( t : timestamp, from : timescale, to : timescale ) : timestamp
     t
   else
     // transform through TAI
-    // trace( "convert: " + from.name + " -> " + to.name +  ", t: " + t.show )
+    // trace( "convert: " ++ from.name ++ " -> " ++ to.name +  ", t: " ++ t.show )
     (to.from-tai)( (from.to-tai)(t) )
 
 

lib/std/time/parse.kk

@@ -145,7 +145,7 @@ pub fun parse-iso( s : string, calendar : calendar = cal-iso ) : <utc> maybe<tim
         Just(capt) ->
           val hours = capt.num(1)
           val mins  = capt.num(2)
-          val secs  = parse-ddouble(capt.groups[3] + "." + capt.groups[4]).default(zero)
+          val secs  = parse-ddouble(capt.groups[3] ++ "." ++ capt.groups[4]).default(zero)
           val tzsign= if capt.groups[5]=="+" then 1 else ~1
           val tzhours= capt.num(6)
           val tzmins = capt.num(7)

lib/std/time/time.kk

@@ -90,7 +90,7 @@ pub fun round-to-prec( t : time, prec : int ) : time
   val c    = t.clock
   val secs = c.seconds.round-to-prec(prec)
   val ri   = t.instant.round-to-prec(prec)
-  //trace("time.round-to-prec: " + t.show-raw + ", t.seconds: " + t.seconds.show + ", secs: " + secs.show)
+  //trace("time.round-to-prec: " ++ t.show-raw ++ ", t.seconds: " ++ t.seconds.show ++ ", secs: " ++ secs.show)
   if secs.truncate == t.seconds.truncate then
     // whole seconds stay the same, just update with the rounded seconds and instant
     t(clock=c(seconds=secs), instant = ri)
@@ -402,7 +402,7 @@ pub fun days-until( t1 : time, t2 : time ) : int
 // `time(2016,12,31,12,0,0).mjd.show(9) == "57753.499994213"` &quad; (this day has a leap second, so it is just before the real middle of the day)\
 // `time(2016,12,31,12,0,0,0.5).mjd.show == "57753.5"` &quad; (real middle of the day)\
 pub fun mjd( t : time ) : ddouble
-  //trace("offset: " + t.tzdelta.show)
+  //trace("offset: " ++ t.tzdelta.show)
   // adjust with the timezone delta so we display the mjd on the date.
   val i = t.instant
   i.mjd( i.timescale, t.tzdelta.timespan )
@@ -420,7 +420,7 @@ Takes leap seconds into account when calculating the fraction of the day,
 see `mjd` for examples.
 */
 pub fun jd( t : time ) : ddouble
-  //trace("offset: " + t.tzdelta.show)
+  //trace("offset: " ++ t.tzdelta.show)
   // adjust with the timezone delta so we display the mjd on the date.
   t.mjd() + jd-epoch-delta
 

lib/std/time/timezone.kk

@@ -16,7 +16,7 @@ The latest version can be found at: <https://github.com/moment/moment-timezone/b
 val tzs = load-timezones()
 println( now().time(tzs.timezone("US/Pacific")).show )
 val zlocal = tzs.guess-local-timezone()
-println( now().time(zlocal).show + " (" + zlocal.tz-name + ")")
+println( now().time(zlocal).show ++ " (" ++ zlocal.tz-name ++ ")")
 println( now().time(tz-local()).show )
 ```
 */
@@ -61,7 +61,7 @@ pub fun load-timezones( fname : path = path(""),
        Just(parse-packed-zones(s))
 
      fn(exn)
-       trace("failed parse: " + exn.show)
+       trace("failed parse: " ++ exn.show)
        Nothing
      })
 
@@ -102,7 +102,7 @@ fun find-offset( i : instant, periods : list<timezone-period> ) : timezone-perio
     Nil -> timezone-period0
     Cons(tzp,earlier) ->
       if (i >= tzp.start.default(i)) then
-        //trace("timezone: " + tzp.abbrv + ", start: " + tzp.start.default(i).time.show)
+        //trace("timezone: " ++ tzp.abbrv ++ ", start: " ++ tzp.start.default(i).time.show)
         tzp
       else 
         find-offset(i,earlier)
@@ -122,12 +122,12 @@ pub fun timezone( tzi : timezone-info ) : timezone
 
 // Show a time zone period.
 pub fun show( tzp : timezone-period) : string
-  tzp.abbrv.pad-right(4) + " " + tzp.offset.show-tzdelta(utc="+00:00") + " from " + tzp.start.map(fn(i){ i.time.show }).default("-infinity")
+  tzp.abbrv.pad-right(4) ++ " " ++ tzp.offset.show-tzdelta(utc="+00:00") ++ " from " ++ tzp.start.map(fn(i){ i.time.show }).default("-infinity")
 
 // Show time zone information.
 pub fun show (tzi : timezone-info, show-periods : bool = False  ) : string
-  tzi.name + ", population: " + tzi.population.show
-    + (if !show-periods then "" else ":\n  " + (tzi.periods)().map(show : timezone-period -> string).join("\n  "))
+  tzi.name ++ ", population: " ++ tzi.population.show
+    + (if !show-periods then "" else ":\n  " ++ (tzi.periods)().map(show : timezone-period -> string).join("\n  "))
 
 
 /*----------------------------------------------------------------------------
@@ -145,7 +145,7 @@ pub fun parse-packed-zones( s : string ) : exn timezones
 
   val zonesarr = zonesfld.lines.map fn(line)
     match line.find(rxzone)    
-      Nothing   -> error("invalid timezone info:\n  " + line)
+      Nothing   -> error("invalid timezone info:\n  " ++ line)
       Just(cap) -> cap.groups[1]
 
   val zones = zonesarr.map(parse-packed-zone)
@@ -158,13 +158,13 @@ pub fun parse-packed-zones( s : string ) : exn timezones
 
   val links = linksfld.lines.map fn(line)
     match line.find(rxlink)
-      Nothing   -> error("invalid timezone link:\n  " + line)
+      Nothing   -> error("invalid timezone link:\n  " ++ line)
       Just(cap) -> (cap.groups[1],cap.groups[2])
 
   val ldict = links.map(fn(link)
     val (key,other) = link
     match zdict[key.normalize]
-      Nothing  -> error("invalid timezone link: unknown time zone: " + key.normalize + ", to: " + other + ", " + zdict.keys.join("\n"))
+      Nothing  -> error("invalid timezone link: unknown time zone: " ++ key.normalize ++ ", to: " ++ other ++ ", " ++ zdict.keys.join("\n"))
       Just(tz) -> (other.normalize,tz(name=other,aliased=True))
    ).dict
 
@@ -177,7 +177,7 @@ val rxlinks = regex(r#""links"\s*:\s*\[([\s\S]*?)^[ \t]*\]"#, multiLine=True)
 val rxlink  = regex(r#"^\s*"([^"\|]+)\|([^"\|]+)",?\s*$"#)
 
 fun parse-packed-zone( s : string ) : exn timezone-info
-  //trace("parseing: " + s)
+  //trace("parseing: " ++ s)
   val parts     = s.split("|")
   val name      = parts[0].default("")
   val abbrs     = parts[1].default("")
@@ -203,7 +203,7 @@ fun parse-packed-periods( name : string, sabbrs : string, soffsets :string, sind
       Nil -> (0.0,[])
       Cons(start,rest) -> (start * 60.0, Cons(0.0,rest))
 
-    if diffs.length + 1 != indices.length  error("invalid timezone data:\n  diffs: " + sxdiffs + "\n  ind  : " + sindices  )
+    if diffs.length + 1 != indices.length  error("invalid timezone data:\n  diffs: " ++ sxdiffs ++ "\n  ind  : " ++ sindices  )
     val endings = diffs.foldl((start0,[]), fn(acc:(float64,list<maybe<instant>>),diff)
                     val iu = acc.fst + diff*60.0
                     val i = unix-instant(iu)
@@ -216,13 +216,13 @@ fun parse-packed-periods( name : string, sabbrs : string, soffsets :string, sind
     periods
 
   fn(exn)
-    trace("invalid timezone database entry for " + name.show + ":\n " + exn.show)
+    trace("invalid timezone database entry for " ++ name.show ++ ":\n " ++ exn.show)
     []
 
 
 fun parse-fixed-base60( s : string ) : exn float64
   match(s.find(rxfixbase60))
-    Nothing -> error("invalid fixed base60 number: " + s)
+    Nothing -> error("invalid fixed base60 number: " ++ s)
     Just(cap) ->
       val sign = if cap.groups[1]=="-" then ~1 else 1
       val num  = parse-base60(cap.groups[2])
@@ -236,7 +236,7 @@ val rxfixbase60 = regex(r"^([\-\+])?([\da-zA-X]*)(?:\.([\da-zA-X]+))?$")
 fun parse-base60( s : string ) : exn int
   if s.is-empty return 0
   match(s.find(rxbase60))
-    Nothing -> error("invalid base60 number: " + s)
+    Nothing -> error("invalid base60 number: " ++ s)
     Just(cap) ->
       val sign = if cap.groups[1]=="-" then ~1 else 1
       val num  = cap.groups[2].list.foldl(0) fn(n,d)
@@ -250,7 +250,7 @@ fun digit60( d : char ) : exn int
   if d.is-digit then (d - '0').int
   elif d.is-lower then (d - 'a').int + 10
   elif d.is-upper then (d - 'A').int + 36
-  else error("invalid digit in base 60: " + d.show)
+  else error("invalid digit in base 60: " ++ d.show)
 
 
 /*----------------------------------------------------------------------------
@@ -323,7 +323,7 @@ pub fun guess-local-timezone( tzs : timezones, default : maybe<timezone> = Nothi
       val offsets = dates.sample-offsets(tz-local())
       val matches = tzs.tzones.list.map(snd).filter fn(tzi)
                       (!tzi.aliased &&  dates.match-offsets(offsets,tzi.timezone))
-      // trace("timezone guess matches: " + matches.show-list(fn(tzi){ tzi.show }))
+      // trace("timezone guess matches: " ++ matches.show-list(fn(tzi){ tzi.show }))
       match matches
         Nil -> match default
           Nothing  -> tz-local()

lib/std/time/ut1.kk

@@ -104,11 +104,11 @@ pub fun load-iersA( basename : string = "finals2000A",
                     verbose : bool = True
                   ) : <io,async> ((i:instant) -> maybe<duration>)
 
-  val fname-all    = basename + ".all"
+  val fname-all    = basename ++ ".all"
   val finals-all   = load-iersA-all( fname-all, baseurl + fname-all,
                                      duration(download-delay.seconds * 8.ddouble),
                                      duration(download-timeout.seconds * 8.ddouble), verbose )
-  val fname-daily  = basename + ".daily"
+  val fname-daily  = basename ++ ".daily"
   val finals-daily = load-iersA-daily( fname-daily, baseurl + fname-daily,
                                        download-delay, download-timeout, verbose )
   (fn(i:instant)
@@ -165,7 +165,7 @@ fun load-latest-iersA( fname : path, url   : string,
   val xurl   = if url=="auto" then usno-url + fname.basename else url
   val dtt    = load-latest( xfname, xurl, parse-iersA, fn(dtt:dut-table){ Just(dtt.expire) },
                             download-timeout=download-timeout,download-delay=download-delay,
-                            error-prefix="load IERS A data (" + fname.basename + ")",
+                            error-prefix="load IERS A data (" ++ fname.basename ++ ")",
                             verbose=verbose
                           )
   val ts-utc = ts-utc-load(verbose=verbose)
@@ -200,10 +200,10 @@ fun dut-deltat( ts-utc : timescale, dtt : dut-table, i : instant ) : maybe<durat
                 elif dut1 - 0.5 > dut2 && dut1 - 1.5 < dut2 then dut2 + 1.0 // a leap second was subtracted
                 else dut1 // a jump outside a reasonable range; don't interpolate
       val dut = dut1 + ((dut3 - dut1) * mjd.fraction)
-      //val _ = trace("dut interpolate: " + dut1.show + ", and " + dut3.show + ", to " + dut.show)
+      //val _ = trace("dut interpolate: " ++ dut1.show ++ ", and " ++ dut3.show ++ ", to " ++ dut.show)
       // calculate deltaT (TT - UT1) from DUT (=UT1 - UTC)
       val dt  = (i.timestamp-in(ts-tt) - dut.ddouble) - utci.timestamp.unsafe-timespan-withleap // include leap seconds!
-      //val _ = trace("dut found: mjd: " + mjd.show + ", dut: " + dut.show + ", dt: " + dt.show)
+      //val _ = trace("dut found: mjd: " ++ mjd.show ++ ", dut: " ++ dut.show ++ ", dt: " ++ dt.show)
       Just( unsafe-duration(dt) )
 
 
@@ -224,9 +224,9 @@ fun parse-iersA( s : string ) : maybe<dut-table>
                   Just(cap) -> cap.groups[1].parse-float64.maybe(end - 365.0)
                   Nothing   -> end - 365.0  // guess one year early
                 ).instant-at-mjd(ts-ti)
-  //trace("finals2000A expire: " + expire.time.show)
-  //trace("entries: " + entries.list.map(fn(d){ show(d) }).join("\n"))
-  //trace("finals: " + entries.length.show + ", start: " + start.show + ", end: " + end.show )
+  //trace("finals2000A expire: " ++ expire.time.show)
+  //trace("entries: " ++ entries.list.map(fn(d){ show(d) }).join("\n"))
+  //trace("finals: " ++ entries.length.show ++ ", start: " ++ start.show ++ ", end: " ++ end.show )
   Just(Dut-table(expire,start,end,entries))
 
 val rx-finals-dut = regex(r"^.{57}[IP]([\-\+ ]\d+(?:\.\d+))", multiline=True)
@@ -248,14 +248,14 @@ fun map-acc(xs : list<a>, f : a -> b, acc : list<b> = []) : list<b>
 fun tai-to-ut1( tai : duration, dt-override : (i:instant) -> maybe<duration> ) : timestamp
   val i  = tai.instant
   val dt = deltat(i,dt-override)
-  // trace("tai-to-ut: dt: " + dt.show )
+  // trace("tai-to-ut: dt: " ++ dt.show )
   (i - dt).timestamp-in(ts-tt)
 
 fun ut1-to-tai( t : timestamp, dt-override : (i : instant) -> maybe<duration> ) : duration
   val i   = ts-tt.instant(t)             // approximately tt
   val i1  = i + deltat(i,dt-override)    // approximate tai
   val i2  = i + deltat(i1,dt-override)   // improve over previous approximation
-  // trace("ut-to-tai: dt1: " + deltat(i0).show + ", dt2: " + deltat(i1).show)
+  // trace("ut-to-tai: dt1: " ++ deltat(i0).show ++ ", dt2: " ++ deltat(i1).show)
   i2.duration
 
 // Takes an optional `dt` parameter to calculate &Delta;T (=TT - UT1)
@@ -341,7 +341,7 @@ pub fun deltat( i : instant, dt-override : (i : instant) -> maybe<duration> = de
               val y = i.time(ts=ts-tt).year-frac.float64.round-to-prec(4)
               deltat-builtin(y).duration
 
-  // trace("deltat: year: " + y.show-ddouble + ", dt: " + dt.show)
+  // trace("deltat: year: " ++ y.show-ddouble ++ ", dt: " ++ dt.show)
   dt
 
 fun deltat-builtin( y : float64,

lib/std/time/utc.kk

@@ -867,7 +867,7 @@ fun ptaiadjust() : parse leap-adjust
   // round to always start on a whole second
   val start  = ((mjd - mjd-epoch-shift)*solar-secs-per-day).round.timestamp
   val dstart = ((dmjd - mjd-epoch-shift)*solar-secs-per-day).round.timestamp
-  // trace("pre72 start=" + start.show + ", ofs: " + ofs.show + ", drift: " + drift.show )
+  // trace("pre72 start=" ++ start.show ++ ", ofs: " ++ ofs.show ++ ", drift: " ++ drift.show )
   Leap-adjust( start, ofs, dstart, drift )
 
 // TAI leap second adjustments for dates before 1972-01-01Z are linear interpolations.
@@ -924,7 +924,7 @@ val utc-expire  = leaps.find(rxexpire).map fn(cap)
     val ntpex = cap.groups[1].parse-int-default(ntp2000.int)
     timestamp(ntpex.timespan - ntp2000)
   }.default(la-final.utc-start + (182*isolar-secs-per-day).timespan)  // default: 6 months after last leap second
-  // trace("expire: " + utc-expire.ts-show)
+  // trace("expire: " ++ utc-expire.ts-show)
   ts-tai.instant( utc-expire - ntp2000 + la-final.offset ) // interpret as TAI to avoid recursion.
 
 val rxexpire = regex(r"^[ \t]*#@[ \t]*(\d+)[ \t]*(?:#.*)?$", multiLine=True)
@@ -940,7 +940,7 @@ pub fun parse-leap-seconds-dat( leaps : string  ) : leaps-table
     // round to always start on a whole second
     val start  = ((mjd - mjd-epoch-shift)*solar-secs-per-day).round.timestamp
     val dstart = ((dmjd - mjd-epoch-shift)*solar-secs-per-day).round.timestamp
-    // trace("pre72 start=" + start.show + ", ofs: " + ofs.show + ", drift: " + drift.show )
+    // trace("pre72 start=" ++ start.show ++ ", ofs: " ++ ofs.show ++ ", drift: " ++ drift.show )
     Leap-adjust( start, ofs, dstart, drift )
   }).reverse
   val expire = parse-leap-expire(leaps,adjusts)

test/algeff/common.kk

@@ -48,7 +48,7 @@ effect input {
 
 fun hello() {
   val name = getstr()
-  println("Hello " + name + ", " + getstr())
+  println("Hello " ++ name ++ ", " ++ getstr())
 }
 
 val always-there = handler {
@@ -193,7 +193,7 @@ fun ask-age() {
   val name = readline()           // asynchronous!
   println("and you age?")
   val age = readline()
-  println("hello " + name + ", you are " + age)
+  println("hello " ++ name ++ ", you are " ++ age)
 }
 
 
@@ -202,10 +202,10 @@ fun ask-age-err() {
     println("what is your name?")
     val name = readline()
     raise("ouch!")
-    println("hello " + name)
+    println("hello " ++ name)
   }
   fn(err) {
-    println("error: " + err )
+    println("error: " ++ err )
   }
 }
 */