Std: rename Display to Show; add Trace; println takes `String…

…` param

data/example.no

@@ -18,11 +18,17 @@ impl Area for Shape {
     }
 }
 
-fn main() {
+pub fn main() {
     let shapes: List<Shape> = [
         Shape::Rect(width: 4., height: 2.),
         Shape::Circle(radius: 12.34),
     ]
-    println(shapes.iter().map(Area::area).collect<List<_>>())
+    println(
+        shapes
+            .iter()
+            .map(|s| { s.area() })
+            .collect<List<_>>()
+            .show()
+    )
 }
 

data/features.no

@@ -1,5 +1,5 @@
 // import
-use std::io::Display
+use std::io::Show
 
 // sum type
 type Vec2(x: Float, y: Float)
@@ -12,8 +12,8 @@ impl Vec2 {
 }
 
 // impl
-impl Display for Vec2 {
-    fn fmt(self): String {
+impl Show for Vec2 {
+    fn show(self): String {
         "(" + self.x + ", " + self.y + ")"
     }
 }
@@ -72,13 +72,10 @@ fn main() {
     println("hello")
 
     // method call
-    vec.fmt()
+    vec.show()
 
     // alternative call syntax
-    Vec2::fmt(vec)
-
-    // method call syntax for ambiguous methods
-    //Vec2::Display::fmt(vec)
+    Vec2::show(vec)
 
     // if
     let d = if true { 4 } else { 2 + 6 }
@@ -132,6 +129,6 @@ fn main() {
     let p = println
 
     // method reference
-    // equivalent to |v: Vec2| v.fmt()
-    let r = Vec2::fmt
+    // equivalent to |v: Vec2| v.show()
+    let r = Vec2::show
 }

data/syntax.no

@@ -1,13 +1,13 @@
 // comment
 use pkg
-use std::io::Display
+use std::io::Show
 use std::iter::{ Iter, peekableIter::PeekableIter }
 type Foo
 type Bar<T>(v: T)
 type V<T>{ A(), B(v: T) }
 trait Baz<U> { fn a(self): Unit fn f<T>(self): T {} }
 impl <T> Baz<Option<T>> for Bar<T> { fn f(self): T {} }
-fn foo<T: std::io::Display + U, U>(b: T): Option<U> {
+fn foo<T: std::io::Show + U, U>(b: T): Option<U> {
     let a = [1, "str", 'c', true, Option::None(), Option::Some(value: 1), Option::Some(2)]
     let Foo::Foo(x) = Foo::Foo(4)
     let b = if a.next().isSome() { a } else { [] }

src/scope/trait.spec.ts

@@ -46,16 +46,16 @@ describe('trait', () => {
         expect(formatImplTypes(findSuperRelChains(vidFromString('std::unit::Unit'), ctx))).toEqual([])
 
         expect(formatImplTypes(findSuperRelChains(vidFromString('std::string::String'), ctx))).toEqual([
-            ['std::io::Display'],
+            ['std::io::show::Show'],
             ['std::eq::Eq'],
             ['std::iter::Collector<std::string::String>']
         ])
 
         expect(formatImplTypes(findSuperRelChains(vidFromString('std::list::List'), ctx))).toEqual([
             ['std::iter::Iterable<T>'],
             ['std::iter::Collector<T>'],
-            ['std::io::Display'],
-            ['std::io::Display']
+            ['std::io::show::Show'],
+            ['std::io::show::Show']
         ])
 
         expect(formatImplTypes(findSuperRelChains(vidFromString('std::list::ListIter'), ctx))).toEqual([

src/scope/trait.ts

@@ -151,7 +151,7 @@ const getImplImplRel = (instance: ImplDef, module: Module, ctx: Context): Instan
  * Every chain corresponds to a single `impl for` where type is assignable to impl trait
  * For all, chain.length > 0
  * For example:
- *   - String   -> [Display for String], [Eq for String], ...]
+ *   - String   -> [Show for String], [Eq for String], ...]
  *   - Iter     -> [[Iterable for Iter], [PeekableAdapter for Iter], [MapAdapter for Iter], ...]
  *   - ListIter -> [[Iter for ListIter], [Iter for ListIter, Iterable for Iter], ...]
  * TODO: detect cases where impl.forType is a generic, e.g. `impl <T: B> A for T`

src/semantic/semantic.spec.ts

@@ -655,7 +655,7 @@ fn main() {
         it('fn named call', () => {
             const code = `\
 fn main() {
-    let foo = println(value: 5)
+    let foo = println(value: "str")
     return unit
 }`
             const ctx = check(code)

src/std/bool.js

@@ -42,7 +42,7 @@ function notBool(a) {
  * @param {Bool} a
  * @returns {String}
  */
-function fmtBool(a) {
+function showBool(a) {
     return String.String(a.value.toString())
 }
 

src/std/bool.no

@@ -1,5 +1,3 @@
-use std::io::Display
-
 pub type Bool {
     True,
     False
@@ -19,9 +17,9 @@ impl Bool {
     }
 }
 
-impl Display for Bool {
-    fn fmt(self): String {
-        fmtBool(self)
+impl Show for Bool {
+    fn show(self): String {
+        showBool(self)
     }
 }
 
@@ -43,7 +41,7 @@ fn orBool(a: Bool, b: Bool): Bool
 
 fn notBool(a: Bool): Bool
 
-fn fmtBool(a: Bool): String
+fn showBool(a: Bool): String
 
 fn eqBool(a: Bool, b: Bool): Bool
 

src/std/char.js

@@ -16,7 +16,7 @@ Char.Char = value => ({
  * @param {Char} a
  * @returns {String}
  */
-function fmtChar(a) {
+function showChar(a) {
     return String.String(a.value)
 }
 

src/std/char.no

@@ -1,10 +1,8 @@
-use std::io::Display
-
 pub type Char
 
-impl Display for Char {
-    fn fmt(self): String {
-        fmtChar(self)
+impl Show for Char {
+    fn show(self): String {
+        showChar(self)
     }
 }
 
@@ -20,6 +18,6 @@ impl Copy for Char {
     }
 }
 
-fn fmtChar(a: Char): String
+fn showChar(a: Char): String
 
 fn eqChar(a: Char, b: Char): Bool

src/std/float.js

@@ -86,6 +86,6 @@ function eqFloat(a, b) {
  * @param {Float} a
  * @returns {String}
  */
-function fmtFloat(a) {
+function showFloat(a) {
     return String.String(a.value.toString())
 }

src/std/float.no

@@ -1,5 +1,3 @@
-use std::io::Display
-
 pub type Float
 
 impl Num for Float {
@@ -38,9 +36,9 @@ impl Eq for Float {
     }
 }
 
-impl Display for Float {
-    fn fmt(self): String {
-        fmtFloat(self)
+impl Show for Float {
+    fn show(self): String {
+        showFloat(self)
     }
 }
 
@@ -68,5 +66,5 @@ fn expFloat(a: Float, b: Float): Float
 
 fn eqFloat(a: Float, b: Float): Bool
 
-fn fmtFloat(a: Float): String
+fn showFloat(a: Float): String
 

src/std/int.js

@@ -101,6 +101,6 @@ function cmpInt(a, b) {
  * @param {Int} a
  * @returns {String}
  */
-function fmtInt(a) {
+function showInt(a) {
     return String.String(a.value.toString())
 }

src/std/int.no

@@ -1,5 +1,3 @@
-use std::io::Display
-
 pub type Int
 
 impl Int {
@@ -50,9 +48,9 @@ impl Ord for Int {
     }
 }
 
-impl Display for Int {
-    fn fmt(self): String {
-        fmtInt(self)
+impl Show for Int {
+    fn show(self): String {
+        showInt(self)
     }
 }
 
@@ -82,5 +80,5 @@ fn eqInt(a: Int, b: Int): Bool
 
 fn cmpInt(a: Int, b: Int): Ordering
 
-fn fmtInt(a: Int): String
+fn showInt(a: Int): String
 

src/std/io/mod.no

@@ -1,9 +1,5 @@
-pub trait Display {
-    fn fmt(self): String
-}
-
-pub fn println(display: Display): Unit {
-    printlnStr(display.fmt())
+pub fn println(string: String): Unit {
+    printlnStr(string)
 }
 
 fn printlnStr(string: String): Unit

src/std/io/show.no

@@ -0,0 +1,4 @@
+pub trait Show {
+    fn show(self): String
+}
+

src/std/io/trace.no

@@ -0,0 +1,4 @@
+pub trait Trace {
+    fn trace(self): String
+}
+

src/std/list.no

@@ -1,4 +1,3 @@
-use std::io::Display
 use std::iter::{ MapAdapter, IntersperseAdapter }
 
 pub type List<T>
@@ -32,8 +31,8 @@ impl <T> Collector<T> for List<T> {
     }
 }
 
-impl Display for List<String> {
-    fn fmt(self): String {
+impl Show for List<String> {
+    fn show(self): String {
         "[".concat(self.iter().intersperse(", ").collect<String>()).concat("]")
     }
 }
@@ -44,10 +43,10 @@ impl Copy for Int {
     }
 }
 
-impl <T: Display> Display for List<T> {
-    fn fmt(self): String {
+impl <T: Show> Show for List<T> {
+    fn show(self): String {
         // TODO: method ref
-        self.iter().map(|d| { d.fmt() }).collect<List<String>>().fmt()
+        self.iter().map(|d| { d.show() }).collect<List<String>>().show()
     }
 }
 

src/std/prelude.no

@@ -15,7 +15,7 @@ pub use std::{
     list::List,
     never::Never,
     panic::{ panic, todo },
-    io::println,
+    io::{ println, show::Show, trace::Trace },
     option::Option::{ self, Some, None },
     result::Result::{ self, Ok, Error },
 }

src/std/string.no

@@ -1,5 +1,3 @@
-use std::io::Display
-
 pub type String
 
 impl String {
@@ -9,8 +7,8 @@ impl String {
     }
 }
 
-impl Display for String {
-    fn fmt(self): String {
+impl Show for String {
+    fn show(self): String {
         self
     }
 }