@effekt-lang/effekt 0.2.2 → 0.3.0

package/libraries/ml/immutable/result.effekt

@@ -1,29 +0,0 @@
-import immutable/option
-
-// Results
-// =======
-// The "reification" of the Exception[E] effect.
-type Result[A, E] {
-  Error(exception: E, msg: String);
-  Success(a: A)
-}
-
-def result[A, E] { f: () => A / Exception[E] }: Result[A, E] = try {
-  Success(f())
-} with Exception[E] {
-  def raise(exc, msg) = Error(exc, msg)
-}
-
-/**
- * Extracts the value of a result, if available
- * Monadic "reflection"
- */
-def value[A, E](r: Result[A, E]): A / Exception[E] = r match {
-  case Success(a) => a
-  case Error(exc, msg) => do raise(exc, msg)
-}
-
-def toOption[A, E](r: Result[A, E]): Option[A] = r match {
-  case Success(a) => Some(a)
-  case Error(exc, msg) => None()
-}

package/libraries/ml/internal/option.effekt

@@ -1,18 +0,0 @@
-module internal/option
-
-import effekt
-import immutable/option
-
-extern type MLOption[T]
-
-extern pure def isDefined[T](opt: MLOption[T]): Boolean =
-  "Option.isSome ${opt}"
-
-def isEmpty[T](opt: MLOption[T]): Boolean = not(opt.isDefined())
-
-extern pure def force[T](opt: MLOption[T]): T =
-  "Option.valOf ${opt}"
-
-def toOption[T](opt: MLOption[T]): Option[T] = {
-    if (isDefined(opt)) Some(force(opt)) else None()
-}

package/libraries/ml/io/args.effekt

@@ -1,41 +0,0 @@
-module io/args
-
-import effekt
-import internal/option
-import immutable/option
-import immutable/list
-
-
-// ================================================
-//
-// Conceptual Public Functions:
-//   - commandLineArgs(): List[String]
-//
-// ================================================
-
-
-// ml Ref of ml list
-extern type Args
-
-// Works like an iterator
-extern io def nativeArgs(): Args =
-  "ref (CommandLine.arguments ())"
-
-extern """
-fun nextArgument a =
-  case !a of
-    [] => NONE |
-    x :: xs => (a := xs; SOME x);
-"""
-
-// consumes the next arg if present
-extern io def nativeNext(a: Args): MLOption[String] =
-  "nextArgument ${a}"
-
-def commandLineArgs(): List[String] = {
-  def argsToRevList(a: Args, acc: List[String]): List[String] = toOption(nativeNext(a)) match {
-    case None() => acc
-    case Some(v) => argsToRevList(a, Cons(v, acc))
-  }
-  reverse(argsToRevList(nativeArgs(), Nil()))
-}

package/libraries/ml/mutable/array.effekt

@@ -1,43 +0,0 @@
-module mutable/array
-
-import immutable/option
-
-// A mutable array, backed by a sml array.
-extern type Array[T]
-
-extern pure def emptyArray[T](): Array[T] =
-    "Array.fromList []"
-
-extern pure def array[T](initialSize: Int, init: T): Array[T] =
-  "Array.array (${initialSize}, ${init})"
-
-def get[T](arr: Array[T], index: Int): Option[T] = {
-    val len = size(arr);
-    if (index < 0 || len <= index) None()
-    else Some(unsafeGet(arr, index))
-}
-
-extern pure def size[T](arr: Array[T]): Int =
-    "Array.length ${arr}"
-
-extern pure def unsafeGet[T](arr: Array[T], index: Int): T =
-    "Array.sub (${arr}, ${index})"
-
-def put[T](arr: Array[T], index: Int, value: T): Unit =
-    if (index < 0 || size(arr) <= index) ()
-    else unsafeput(arr, index, value)
-
-extern io def unsafeput[T](arr: Array[T], index: Int, value: T): Unit =
-    "Array.update (${arr}, ${index}, ${value})"
-
-def copy[T](arr: Array[T]): Array[T] =
-    get(arr, 0) match {
-        case None() => emptyArray()
-        case Some(first) =>
-            val dst = array(size(arr), first)
-            copyInto(arr, dst);
-            dst
-    }
-
-extern pure def copyInto[T](src: Array[T], dst: Array[T]): Unit =
-    "Array.copy {src = ${src}, dst = ${dst}, di = 0}"

package/libraries/ml/test.effekt

@@ -1,60 +0,0 @@
-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)
-
-// Note: every other backend uses a generic `show` instead
-def assertEqual[A](obtained: A, expected: A) { show : A => String } =
-  do assert(obtained == expected, "Obtained: " ++ show(obtained) ++ "\n but expected:" ++ show(expected))
-
-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
-  }
-}

package/libraries/ml/text/string.effekt

@@ -1,81 +0,0 @@
-module text/string
-
-import effekt
-import immutable/option
-import internal/option
-
-// For more information on the sml string type:
-//    https://smlfamily.github.io/Basis/string.html#String:STR:SPEC
-
-def charAt(str: String, index: Int): Option[String] =
-    if (index < 0 || length(str) <= index)
-        Some(unsafeCharAt(str, index))
-    else None()
-
-extern pure def length(str: String): Int =
-    "String.size ${str}"
-
-extern pure def startsWith(str: String, prefix: String): Boolean =
-    "String.isPrefix ${prefix} ${str}"
-
-extern pure def endsWith(str: String, suffix: String): Boolean =
-    "String.isSuffix ${suffix} ${str}"
-
-// extern pure def repeat(str: String, n: Int): String =
-//     "???"
-
-def substring(str: String, from: Int, to: Int): String = {
-    def clamp(lower: Int, x: Int, upper: Int) = max(lower, min(x, upper))
-
-    val len = str.length
-    val clampedTo = clamp(0, to, len)
-    val clampedFrom = clamp(0, from, to)
-
-    val substringLength = max(0, clampedTo - clampedFrom)
-    str.unsafeSubstring(clampedFrom, substringLength)
-}
-
-def substring(str: String, from: Int): String =
-    str.substring(from, str.length)
-
-extern pure def unsafeSubstring(str: String, from: Int, len: Int): String =
-    "String.extract (${str}, ${from}, SOME ${len})"
-
-// extern pure def split(str: String, sep: String): Array[String] =
-//     "Array.fromList (map (String.str) (String.explode str))"
-
-// extern pure def trim(str: String): String =
-//     "???"
-
-// also accepts sml style `~2` for unary minus along with `+2` and `-2`
-extern pure def internalStringToInt(str: String): MLOption[Int] =
-    "Int.fromString ${str}"
-
-def toInt(str: String): Option[Int] = toOption(internalStringToInt(str))
-
-extern pure def unsafeCharAt(str: String, n: Int): String =
-    "String.sub (${str}, ${n})"
-
-def indexOf(str: String, sub: String): Option[Int] = {
-    def loop(str: String, sub: String, index: Int): Int = {
-        if (index >= str.length) { -1 }
-        else if (str.substring(index).startsWith(sub)) { index }
-        else { loop(str, sub, index + 1) }
-    }
-    val index = loop(str, sub, 0)
-    if (index == -1) { None() } else { Some(index) }
-}
-
-def lastIndexOf(str: String, sub: String): Option[Int] = {
-    def loop(str: String, sub: String, index: Int): Int = {
-        if (index < 0) { -1 }
-        else if (str.substring(index).startsWith(sub)) { index }
-        else { loop(str, sub, index - 1) }
-    }
-    val index = loop(str, sub, str.length)
-    if (index == -1) { None() } else { Some(index) }
-}
-
-val ANSI_GREEN = "\u001b[32m"
-val ANSI_RED = "\u001b[31m"
-val ANSI_RESET = "\u001b[0m"