stdlib: rename has to includes, add missing Identity bounds

works on #88

dora/stdlib/collections.dora

@@ -278,11 +278,11 @@ impl[T: Equals] Array[T] {
 }
 
 impl[T: Identity] Array[T] {
-  @pub fun has(value: T): Bool {
+  @pub fun includes(val: T): Bool {
     var i = 0i64;
 
     while i < self.size() {
-      if self.get(i).identicalTo(value) {
+      if self.get(i).identicalTo(val) {
         return true;
       }
       i = i + 1i64;
@@ -1347,11 +1347,11 @@ impl[T: Equals] List[T] {
 }
 
 impl[T: Identity] List[T] {
-  @pub fun has(value: T): Bool {
+  @pub fun includes(val: T): Bool {
     var i = 0i64;
 
     while i < self.size() {
-      if self.get(i).identicalTo(value) {
+      if self.get(i).identicalTo(val) {
         return true;
       }
       i = i + 1i64;

dora/stdlib/primitives.dora

@@ -467,10 +467,6 @@ impl[T] Option[T] {
     ... is Some(value) { value }
     ... is None        { alt   };
 
-  @pub fun has(val: T): Bool = if self
-    ... is Some(actual) { actual === val }
-    ... is None         { false };
-
   @pub fun all(fct: (T): Bool): Bool = if self
     ... is Some(val) { fct(val) }
     ... is None      { true     };
@@ -514,6 +510,12 @@ impl[T: Identity] Identity for Option[T] {
   @pub fun identicalTo(rhs: Option[T]): Bool = self === rhs;
 }
 
+impl[T: Identity] Option[T] {
+  @pub fun includes(val: T): Bool = if self
+    ... is Some(actual) { actual.identicalTo(val) }
+    ... is None         { false };
+}
+
 impl[T: Equals] Equals for Option[T] {
   @pub fun equals(rhs: Option[T]): Bool {
     if self.isSome() {
@@ -585,10 +587,6 @@ impl[T, E] Result[T, E] {
     ... is Ok(_)      { fatalError("cannot unwrap Ok."); unreachable[E]() }
     ... is Err(value) { value };
 
-  @pub fun has(val: T): Bool = if self
-    ... is Ok(actual) { actual === val }
-    ... is Err(_)     { false };
-
   @pub fun all(fct: (T): Bool): Bool = if self
     ... is Ok(val) { fct(val) }
     ... is Err(_)  { true     };
@@ -634,6 +632,12 @@ impl[T: Identity, E] Identity for Result[T, E] {
   @pub fun identicalTo(rhs: Result[T, E]): Bool = self === rhs;
 }
 
+impl[T: Identity, E] Result[T, E] {
+  @pub fun includes(val: T): Bool = if self
+    ... is Ok(actual) { actual.identicalTo(val) }
+    ... is Err(_)     { false };
+}
+
 impl[T: Equals, E] Result[T, E] {
   @pub fun contains(rhs: T): Bool = if self
     ... is Ok(val) { val.equals(rhs) }

tests/array/array-has.dora → tests/array/array-includes.dora

@@ -1,13 +1,13 @@
 fun main(): Unit {
     let x = Array[Bool]::fill(3i64, true);
-    assert(x.has(true));
+    assert(x.includes(true));
 
     let x = Array[Int32]::fill(3i64, 3i32);
-    assert(x.has(3i32));
+    assert(x.includes(3i32));
 
     let x = Array[Int64]::fill(3i64, 3i64);
-    assert(x.has(3i64));
+    assert(x.includes(3i64));
 
     let x = Array[Float64]::fill(3i64, 0.0/0.0);
-    assert(x.has(0.0/0.0));
+    assert(x.includes(0.0/0.0));
 }

tests/stdlib/option2.dora

@@ -2,7 +2,7 @@ fun main(): Unit {
   let x = None[Int32];
   assert(x.isNone());
   assert(x.isSome().not());
-  assert(x.has(0i32).not());
+  assert(x.includes(0i32).not());
   assert(x.contains(0i32).not());
   assert(x.equals(None[Int32]));
   assert(x.equals(Some[Int32](0i32)).not());
@@ -12,7 +12,7 @@ fun main(): Unit {
   assert(x.isSome());
   assert(x.isNone().not());
   assert(x.getOrPanic() == 42i32);
-  assert(x.has(42i32));
+  assert(x.includes(42i32));
   assert(x.contains(42i32));
   assert(x.equals(Some[Int32](42i32)));
   assert(x.equals(Some[Int32](2i32)).not());

tests/stdlib/result-has.dora → tests/stdlib/result-includes.dora

@@ -4,8 +4,8 @@ fun main(): Unit {
   let er1 = Result[Int32, String]::Err("err1");
   let nan = Result[Float64, String]::Ok(0.0/0.0);
 
-  assert(ok1.has(ok));
-  assert(ok1.has("ok").not());
-  assert(er1.has(23i32).not());
-  assert(nan.has(0.0/0.0));
+  assert(ok1.includes(ok));
+  assert(ok1.includes("ok").not());
+  assert(er1.includes(23i32).not());
+  assert(nan.includes(0.0/0.0));
 }

tests/string/string-indexOfFirst.dora

@@ -9,11 +9,11 @@ fun main(): Unit {
 }
 
 fun testBothEmpty(): Unit {
-  assert("".indexOfFirst("").has(0i64));
+  assert("".indexOfFirst("").includes(0i64));
 }
 
 fun testNeedleEmpty(): Unit {
-  assert("abc".indexOfFirst("").has(0i64));
+  assert("abc".indexOfFirst("").includes(0i64));
 }
 
 fun testHaystackEmpty(): Unit {
@@ -25,14 +25,14 @@ fun testNeedleLarger(): Unit {
 }
 
 fun testSuccess(): Unit {
-  assert("abcdef".indexOfFirst("abc").has(0i64));
-  assert("defabc".indexOfFirst("abc").has(3i64));
-  assert("ababbaadef".indexOfFirst("aa").has(5i64));
-  assert("apapplapple".indexOfFirst("apple").has(6i64));
+  assert("abcdef".indexOfFirst("abc").includes(0i64));
+  assert("defabc".indexOfFirst("abc").includes(3i64));
+  assert("ababbaadef".indexOfFirst("aa").includes(5i64));
+  assert("apapplapple".indexOfFirst("apple").includes(6i64));
 }
 
 fun testMultipleMatch(): Unit {
-  assert("abcdefabc".indexOfFirst("abc").has(0i64));
+  assert("abcdefabc".indexOfFirst("abc").includes(0i64));
 }
 
 fun testFailure(): Unit {