Std: update scoping rules for trait fns

src/std/copy.no

@@ -1,5 +1,3 @@
 pub trait Copy {
     copy = fn(self): Self
 }
-
-pub let copy = fn<T>(value: T): T

src/std/future/runtime.no

@@ -1,6 +1,6 @@
 use std::future::{ self, FutureState, state, subscribers }
 use std::list::{ add, count, popAt, clear, popFront }
-use std::iter::{ Iter::position }
+use std::iter::position
 use std::ref::eqRef
 
 pub type Runtime(

src/std/iter/intersperseIter.no

@@ -1,4 +1,4 @@
-use std::iter::{ PeekableIter, PeekableAdapter }
+use std::iter::peekable::PeekableIter
 
 pub type IntersperseIter<T>(
     iter: PeekableIter<T>,

src/std/iter/mod.no

@@ -1,8 +1,8 @@
 pub use std::iter::{
-    intersperseIter::{ IntersperseIter, IntersperseAdapter },
-    mapIter::{ MapIter, MapAdapter },
-    peekable::{ PeekableIter, PeekableAdapter },
-    takeWhile::{ TakeWhileIter, TakeWhileAdapter },
+    intersperseIter::intersperse,
+    mapIter::map,
+    peekable::{ peekable, peek },
+    takeWhile::takeWhile,
 }
 
 pub trait Iterable<T> {
@@ -32,31 +32,29 @@ pub trait Iter<T> {
         return res
     }
 
-    position = fn(self, f: fn(elem: T): Bool): Option<Int> {
-        let i = 0
+    find = fn(self, f: fn(elem: T): Bool): Option<T> {
         for n in self {
             match f(n) {
                 true { return Some(i) }
             }
-            i = i + 1
         }
         None()
     }
 
-    find = fn(self, f: fn(elem: T): Bool): Option<T> {
+    collect = fn<C: Collector<T>>(self): C {
+        fromIter<C>(self)
+    }
+
+    position = fn(self, f: fn(elem: T): Bool): Option<Int> {
+        let i = 0
         for n in self {
             match f(n) {
                 true { return Some(i) }
             }
+            i = i + 1
         }
         None()
     }
-
-    collect = fn<C: Collector<T>>(self): C {
-        // TODO
-        // C::fromIter(self)
-        todo()
-    }
 }
 
 impl <T> Iterable<T> for Iter<T> {

src/std/iter/peekable.no

@@ -1,5 +1,3 @@
-use std::iter::Iter::next
-
 pub type PeekableIter<T>(
     iter: Iter<T>,
     peeked: Option<Option<T>>

src/std/list.no

@@ -1,5 +1,3 @@
-use std::iter::{ MapAdapter, IntersperseAdapter }
-
 pub type List<T>
 
 pub let at = fn<T>(list: List<T>, index: Int): Option<T> {

src/std/option.no

@@ -38,6 +38,7 @@ pub let unwrap = fn<T>(option: Option<T>): T {
 }
 
 impl <T> Unwrap<T> for Option<T> {
+    // TODO: use identity fn
     bind = fn(self): Option<T> {
         self
     }

src/std/prelude.no

@@ -1,24 +1,24 @@
 pub use std::{
     unit::{ Unit, unit },
     never::Never,
-    float::{ self, Float },
-    int::{ self, Int },
-    string::{ self, String },
-    char::{ self, Char },
-    bool::{ self, Bool, not },
-    num::Num,
-    eq::Eq,
+    float::{ Float },
+    int::{ Int, mod },
+    string::{ String, concat },
+    char::{ Char },
+    bool::{ Bool, and, or, not },
+    num::{ Num, neg, abs, add, sub, mult, div, exp },
+    eq::{ Eq, eq, ne },
     copy::{ Copy, copy },
-    ord::{ Ordering, Ord },
-    iter::{ Iterable::{ self, iter }, Iter, Collector },
+    ord::{ Ordering, Less, Equal, Greater, Ord, cmp, ge, le, gt, lt },
+    iter::{ self, Iterable, iter , Iter, next, count, last, fold, find, collect, Collector },
     iter::range::range,
     iter::repeat::repeat,
     list::{ self, List },
     panic::{ panic, todo },
     unwrap::{ Unwrap },
-    io::{ self, println },
-    fmt::{ show::Show, trace::Trace },
-    option::{ self, Option, Some, None },
-    result::{ self, Result, Ok, Error },
+    io::{ println },
+    fmt::{ show::{ Show, show }, trace::{ Trace, trace } },
+    option::{ Option, Some, None, isSome, isNone },
+    result::{ Result, Ok, Error, isOk, isError, ok, error },
     future::Future,
 }

src/std/string.no

@@ -1,5 +1,3 @@
-use std::iter::MapAdapter
-
 pub type String
 
 // TODO: belongs to the Monoid trait