@effekt-lang/effekt 0.2.1 → 0.2.2

package/libraries/chez/common/io/args.effekt

@@ -0,0 +1,20 @@
+module io/args
+
+import effekt
+import immutable/option
+import immutable/cslist
+import immutable/list
+
+
+// ================================================
+//
+// Conceptual Public Functions:
+//   - commandLineArgs(): List[String]
+//
+// ================================================
+
+// Arguments passed to the script, first one is the file name itself, which we ignore.
+extern io def nativeArgs(): CSList[String] =
+  "(cdr (command-line))"
+
+def commandLineArgs(): List[String] = nativeArgs().fromChez

package/libraries/chez/common/mutable/array.effekt

@@ -0,0 +1,27 @@
+module mutable/array
+
+import immutable/option
+import immutable/cslist
+
+// a mutable array backed by a scheme vector
+extern type Array[T]
+
+extern pure def emptyArray[T](size: Int): Array[T] =
+  "(make-vector ${size})"
+
+def get[T](arr: Array[T], index: Int): Option[T] =
+  if (index >= arr.size) None() else Some(arr.unsafeGet(index))
+
+extern pure def size[T](arr: Array[T]): Int =
+  "(vector-length ${arr})"
+
+// raises a scheme exception if out of bounds
+extern pure def unsafeGet[T](arr: Array[T], index: Int): T =
+  "(vector-ref ${arr} ${index})"
+
+// TODO raises a scheme exception if out of bounds
+extern io def put[T](arr: Array[T], index: Int, value: T): Unit =
+  "(begin (vector-set! ${arr} ${index} ${value}) #f)"
+
+extern pure def toArray[A](l: CSList[A]): Array[A] =
+  "(list->vector ${l})"

package/libraries/chez/common/mutable/dict.effekt

@@ -0,0 +1,30 @@
+module mutable/dict
+
+import immutable/option
+
+// https://cisco.github.io/ChezScheme/csug9.5/compat.html#g148
+extern type Dict[K, V]
+
+extern io def emptyDict[K, V](): Dict[K, V] =
+    "(make-eq-hashtable)"
+
+extern io def emptyWeakDict[K, V](): Dict[K, V] =
+    "(make-hash-table #t)"
+
+extern io def put[K, V](d: Dict[K, V], key: K, value: V): Unit =
+    "(put-hash-table! ${d} ${key} ${value})"
+
+extern io def get[K, V](d: Dict[K, V], key: K, default: V): V =
+    "(hashtable-ref ${d} ${key} ${default})"
+
+extern io def unsafeGet[K, V](d: Dict[K, V], key: K): V =
+    "(hashtable-ref ${d} ${key} #f)"
+
+extern io def contains[K, V](d: Dict[K, V], key: K): Boolean =
+    "(hashtable-contains? ${d} ${key})"
+
+extern io def remove[K, V](d: Dict[K, V], key: K): Unit =
+    "(remove-hash-table! ${d} ${key})"
+
+def get[K, V](d: Dict[K, V], key: K): Option[V] =
+    undefinedToOption(unsafeGet(d, key))

package/libraries/chez/common/mutable/heap.effekt

@@ -0,0 +1,12 @@
+module mutable/heap
+
+extern type Ref[T]
+
+extern io def fresh[T](init: T): Ref[T] =
+    "(box ${init})"
+
+extern io def put[T](ref: Ref[T], value: T): Unit =
+    "(set-box! ${ref} ${value})"
+
+extern io def get[T](ref: Ref[T]): T =
+    "(unbox ${ref})"

package/libraries/chez/common/test.effekt

@@ -0,0 +1,59 @@
+import text/string
+
+interface Assertion {
+  def assert(condition: Boolean, msg: String): Unit
+}
+
+def assertTrue(condition: Boolean, msg: String) =
+  do assert(condition, msg)
+
+def assertTrue(condition: Boolean) =
+  do assert(condition, "Assertion failed")
+
+def assertFalse(condition: Boolean, msg: String) =
+  do assert(not(condition), msg)
+
+def assertFalse(condition: Boolean) =
+  do assert(not(condition), "Assertion failed")
+
+def assertEqual[A](obtained: A, expected: A, msg: String) =
+  do assert(obtained == expected, msg)
+
+def assertEqual[A](obtained: A, expected: A) =
+  do assert(obtained == expected, "Obtained: " ++ obtained.show ++ "\n but expected:" ++ expected.show)
+
+interface Test {
+  def success(name: String): Unit
+  def failure(name: String, msg: String): Unit
+}
+
+def test(name: String) { body: => Unit / Assertion } =
+  try { body(); do success(name) } with Assertion {
+    def assert(condition, msg) = if (condition) resume(()) else do failure(name, msg)
+  }
+
+def suite(name: String) { body: => Unit / Test }: Boolean = {
+  println("Running suite: " ++ name);
+  var failed = 0
+  var passed = 0
+
+  try { body() } with Test {
+    def success(name) = {
+      passed = passed + 1
+      println(ANSI_GREEN ++ "+ " ++ name ++ "" ++ ANSI_RESET);
+      resume(())
+    }
+    def failure(name, msg) = {
+      failed = failed + 1
+      println(ANSI_RED ++ "- (FAIL) " ++ name ++ "\n    " ++ msg ++ ANSI_RESET);
+      resume(())
+    }
+  }
+  if (failed > 0) {
+    println(ANSI_RED ++ "Some tests failed (" ++ passed.show ++ " passed, " ++ failed.show ++ " failed)" ++ ANSI_RESET)
+    false
+  } else {
+    println(ANSI_GREEN ++ "All tests passed (" ++ passed.show ++ " passed)" ++ ANSI_RESET)
+    true
+  }
+}