@effekt-lang/effekt 0.2.2 → 0.4.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/random.effekt

@@ -1,85 +0,0 @@
-module random
-
-/**
- * Imperative Random Numbers
- * -------------------------
- * The following are simple bindings for the following SML/NJ module:
- *   https://www.smlnj.org/doc/smlnj-lib/Util/str-Random.html
- *
- * They are not supposed to be used directly, but only via the
- * effect [[Random]], below.
- */
-extern type RNG // = int * int
-extern io def seed(n: Int, m: Int): RNG = "Random.rand (${n}, ${m})"
-extern pure def toString(s: RNG): String = "Random.toString ${s}"
-
-extern io def int(s: RNG): Int = "Random.randInt ${s}"
-extern io def int(s: RNG, from: Int, to: Int): Int = "Random.randRange (${from}, ${to}) ${s}"
-extern io def double(s: RNG): Double = "Random.randReal ${s}"
-
-
-/**
- * Functional Random Numbers
- * -------------------------
- * The following are simple bindings for the following SML/NJ module:
- *   https://www.smlnj.org/doc/smlnj-lib/Util/str-Rand.html
- *
- * They are not supposed to be used directly, but only via the
- * effect [[Random]], below.
- */
-extern type PseudoRNG
-extern pure def random(s: PseudoRNG): PseudoRNG =
-  "Rand.random ${s}"
-extern pure def range(s: PseudoRNG, n: Int, m: Int): Int =
-  "Rand.range (${n}, ${m}) ${s}"
-extern pure def norm(s: PseudoRNG): Double =
-  "Rand.norm ${s}"
-
-// converting two integers into a word that is between randMin and randMax is completely made up
-extern pure def pseudo(n: Int, m: Int): PseudoRNG =
-  "Word.fromInt ((Word.toInt Rand.randMin) + ((abs (${n} * ${m})) mod (Word.toInt Rand.randMax)))"
-
-
-
-// "Public" API
-// ------------
-
-/**
- * A random number generator.
- *
- * Supposed to be used as an effect: `do randomInt(0, 10)`.
- * There are two canonical implementations as effect handlers (see below).
- */
-interface Random {
-  // returns a random integer between `from` and `to`
-  def randomInt(from: Int, to: Int): Int
-  // returns a random double between 0.0 and 1.0
-  def randomDouble(): Double
-}
-
-/**
- * Imperative random numbers. Does not perform backtracking.
- */
-def withRandom[R](n: Int, m: Int) { prog: => R / Random } = {
-  // should be second class, is mutated...
-  val rng = seed(n, m)
-  try { prog() }
-  with Random {
-    def randomInt(from, to) = resume(rng.int(from, to))
-    def randomDouble() = resume(rng.double())
-  }
-}
-
-/**
- * Functional, pseudo random numbers. According to SMLNJ docs it is faster than the imperative version
- */
-def withPseudoRandom[R](n: Int, m: Int) { prog: => R / Random } = {
-  // should be second class, is mutated...
-  var rng = pseudo(n, m)
-  def next() = rng = random(rng);
-  try { prog() }
-  with Random {
-    def randomInt(from, to) = { next(); resume(rng.range(from, to)) }
-    def randomDouble() = { next(); resume(rng.norm()) }
-  }
-}

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/regex.effekt

@@ -1,107 +0,0 @@
-module text/regex
-
-extern type MLList[Elem] // = 'elem list
-extern pure def isEmpty[A](l: MLList[A]): Boolean = "null ${l}"
-extern pure def head[A](l: MLList[A]): A = "hd ${l}"
-extern pure def tail[A](l: MLList[A]): MLList[A] = "tl ${l}"
-
-def toList[A](l: MLList[A]): List[A] =
-  if (l.isEmpty) Nil() else Cons(l.head, toList(l.tail))
-
-extern type Char // TODO move to text/string
-type Chars = MLList[Char]
-
-
-extern pure def chars(str: String): Chars = "String.explode ${str}"
-extern pure def toString(chars: Chars): String = "String.implode ${chars}"
-
-extern """
-
-(** The RegExp module is created by choosing a parser (P) and an engine (E)
-  * for regular expressions.
-  *
-  * There is no big choice for the parser, since only Awk syntax is supported.
-  * For the regular expression engine, we choose Ken Thompson's algorighm.
-  *
-  * Also see:
-  *   <https://stackoverflow.com/questions/35462919/how-to-use-regex-in-smlnj>
-  *   <https://www.smlnj.org/doc/smlnj-lib/RegExp/fun-RegExpFn.html>
-  *)
-structure RegExp = RegExpFn(
-  structure P = AwkSyntax
-  structure E = ThompsonEngine
-  (* structure E = BackTrackEngine *)
-  (* structure E = DfaEngine *)
-)
-"""
-
-// The type of regular expressions (ML representation)
-extern type Regex
-
-record Match(matched: String)
-
-// TODO handle CannotParse and CannotCompile ml exceptions.
-extern pure def regex(regexString: String): Regex =
-  "RegExp.compileString ${regexString}"
-
-
-// A stream of elements of type Elem, read from a source of type Source
-extern type MLStream[Elem, Source] // = ('elem, 'source) StringCvt.reader
-
-// Internal ml type that represents matches
-//   <https://www.smlnj.org/doc/smlnj-lib/RegExp/str-MatchTree.html>
-extern type MLMatchResult // = match * char list
-
-extern """
-type regex_match = {len: int, pos: char list} MatchTree.match_tree;
-fun matchedString (match : regex_match * char list) =
-  let val res = MatchTree.root (#1 match)
-  in String.implode (List.take (#pos res, #len res)) end;
-
-fun remainderChars (match : regex_match * char list) =
-  let val res = MatchTree.root (#1 match)
-  in List.drop (#pos res, #len res) end;
-
-(** The remainder is just a draft and doesn't work yet...) *)
-
-(** MatchTree -> string list **)
-fun allMatched (matchtree: regex_match) =
-  MatchTree.foldl (fn (m, b) => (String.implode (List.take (#pos m, #len m))) :: b) nil matchtree
-fun allBut str = RegExp.compileString ("[^" ^ str ^ "]+");
-
-fun unsafeSplit str sep =
-  case (RegExp.find (allBut str) List.getItem (String.explode str)) of
-      NONE => nil
-    | SOME v => allMatched (#1 v);
-"""
-
-extern pure def getMatch(result: MLMatchResult): String =
-  "matchedString ${result}"
-extern pure def getRemainder(result: MLMatchResult): Chars =
-  "remainderChars ${result}"
-
-extern pure def unsafeSplit(str: String, ch: Char): MLList[String] =
-  "String.fields (fn c => c = ${ch}) ${str}"
-
-extern pure def unsafeMatchPrefix(r: Regex, str: Chars): MLOption[MLMatchResult] =
-  "RegExp.prefix ${r} List.getItem ${str}"
-
-extern pure def unsafeSplit(str: String, sep: String): MLList[String] =
-  "unsafeSplit ${str} ${sep}"
-
-extern """
-val NEWLINE_CHAR = #"\n";
-"""
-
-extern pure def unsafeLines(str: String): MLList[String] =
-  "String.fields (fn c => c = NEWLINE_CHAR) ${str}"
-
-def lines(str: String): List[String] = unsafeLines(str).toList
-
-def split(str: String, sep: String): List[String] = unsafeSplit(str, sep).toList
-
-def exec(reg: Regex, str: String): Option[Match] = {
-  val matched = reg.unsafeMatchPrefix(str.chars)
-  if (matched.isDefined) { Some(Match(matched.force.getMatch())) }
-  else { None() }
-}

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"