@effekt-lang/effekt 0.3.0 → 0.5.0

package/libraries/js/io.js

@@ -1,143 +0,0 @@
-
-/**
- * Maps the error code to a Effekt-stable (platform independent) numeric value.
- *
- * Tries to use most common errno integer values, but introduces fresh values (> 200)
- * for those without common errno values.
- */
-function errnoToStableId(errorName) {
-    const errorMap = {
-        EPERM: 1,
-        ENOENT: 2,
-        ESRCH: 3,
-        EINTR: 4,
-        EIO: 5,
-        ENXIO: 6,
-        E2BIG: 7,
-        EBADF: 9,
-        EAGAIN: 11,
-        ENOMEM: 12,
-        EACCES: 13,
-        EFAULT: 14,
-        EBUSY: 16,
-        EEXIST: 17,
-        EXDEV: 18,
-        ENODEV: 19,
-        ENOTDIR: 20,
-        EISDIR: 21,
-        EINVAL: 22,
-        ENFILE: 23,
-        EMFILE: 24,
-        ENOTTY: 25,
-        ETXTBSY: 26,
-        EFBIG: 27,
-        ENOSPC: 28,
-        ESPIPE: 29,
-        EROFS: 30,
-        EMLINK: 31,
-        EPIPE: 32,
-        ERANGE: 34,
-        ENAMETOOLONG: 36,
-        ELOOP: 40,
-        EOVERFLOW: 75,
-        EFTYPE: 79,
-        EILSEQ: 84,
-        ENOTSOCK: 88,
-        EDESTADDRREQ: 89,
-        EMSGSIZE: 90,
-        EPROTOTYPE: 91,
-        ENOPROTOOPT: 92,
-        EPROTONOSUPPORT: 93,
-        ESOCKTNOSUPPORT: 94,
-        ENOTSUP: 95,
-        EAFNOSUPPORT: 97,
-        EADDRINUSE: 98,
-        EADDRNOTAVAIL: 99,
-        ENETDOWN: 100,
-        ENETUNREACH: 101,
-        ECONNABORTED: 103,
-        ECONNRESET: 104,
-        ENOBUFS: 105,
-        EISCONN: 106,
-        ENOTCONN: 107,
-        ETIMEDOUT: 110,
-        ECONNREFUSED: 111,
-        EHOSTUNREACH: 113,
-        EALREADY: 114,
-        ECANCELED: 125,
-        EAI_ADDRFAMILY: 200,
-        EAI_AGAIN: 201,
-        EAI_BADFLAGS: 202,
-        EAI_BADHINTS: 203,
-        EAI_CANCELED: 204,
-        EAI_FAIL: 205,
-        EAI_FAMILY: 206,
-        EAI_MEMORY: 207,
-        EAI_NODATA: 208,
-        EAI_NONAME: 209,
-        EAI_OVERFLOW: 210,
-        EAI_PROTOCOL: 211,
-        EAI_SERVICE: 212,
-        EAI_SOCKTYPE: 213,
-        ECHARSET: 215,
-        ENONET: 216,
-        UNKNOWN: 217,
-        EOF: 218,
-        EUNATCH: 219,
-        ESHUTDOWN: 220
-    };
-
-    return errorMap[errorName] || -1; // Default to -1 for unknown error names
-}
-
-function openFile(path, mode, onSuccess, onFailure) {
-  fs.open(path, mode,
-    (err, fd) => {
-      if (!!err) {
-        console.error(err)
-        return onFailure(errnoToStableId(err.code)).run();
-      } else {
-        return onSuccess(fd).run();
-      }
-    });
-  return $effekt.unit;
-}
-
-function readFile(fd, buffer, offset, onSuccess, onFailure) {
-  let position = offset === -1 ? null : offset;
-  fs.read(fd, toBuffer(buffer), 0, buffer.length, position,
-    (err, bytesRead) => {
-      if (!!err) {
-        return onFailure(errnoToStableId(err.code)).run()
-      } else {
-        return onSuccess(bytesRead).run()
-      }
-    })
-  return $effekt.unit;
-}
-
-/**
- * @see {https://nodejs.org/api/fs.html#fswritefd-buffer-offset-length-position-callback
- */
-function writeFile(fd, buffer, offset, onSuccess, onFailure) {
-  let position = offset === -1 ? null : offset;
-  fs.write(fd, toBuffer(buffer), 0, buffer.length, position,
-    (err, bytesWritten) => {
-      if (!!err) {
-        return onFailure(errnoToStableId(err.code)).run()
-      } else {
-        return onSuccess(bytesWritten).run()
-      }
-    })
-  return $effekt.unit;
-}
-
-
-
-/**
- * Nodejs file operations expect buffers, but we represent buffers as typed arrays.
- * This function converts between the two without copying.
- */
-function toBuffer(buffer) {
-  return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
-}

package/libraries/llvm/io.ll

@@ -1,19 +0,0 @@
-declare i64 @uv_error_to_errno(i64)
-declare ptr @uv_strerror(i32)
-
-declare ptr @uv_default_loop()
-declare i32 @uv_run(ptr, i32)
-declare void @uv_stop(ptr)
-declare void @uv_loop_close(ptr)
-
-; Helpers defined in C
-declare void @c_timer_wait(i64, %Neg)
-declare i64 @c_file_open(%Pos, %Pos, %Neg, %Neg)
-declare void @c_file_close(%Pos)
-declare void @c_file_read(i32, %Pos, i64, ptr, ptr)
-declare void @c_file_write(i32, %Pos, i64, ptr, ptr)
-declare %Pos @c_filedescriptor_show(%Pos)
-
-declare %Pos @c_promise_make()
-declare void @c_promise_resolve(%Pos, %Pos)
-declare void @c_promise_await(%Pos, %Neg)

package/libraries/ml/effekt.sml

@@ -1,65 +0,0 @@
-(* EVIDENCE *)
-fun lift m k1 k2 = m (fn a => k1 a k2);
-fun nested ev1 ev2 m = ev1 (ev2 m);
-fun here x = x;
-
-(* REGIONS *)
-(* type region = ((() -> () -> ()) list) ref *)
-fun newRegion () = ref nil
-fun backup cell = fn () => let val oldState = !cell in fn () => cell := oldState end
-fun fresh r init = let val cell = ref init in (r := (backup cell) :: (!r); cell) end
-fun withRegion body =
-    let val r = newRegion()
-        fun lift m k = let val fields = map (fn f => f()) (!r) in
-            m (fn a => (map (fn f => f()) fields; k a)) end
-    in body lift r end
-
-(* SHOW INSTANCES *)
-fun show'int x =
-    let val s = (Int.toString x) in
-    case String.sub (s, 0) of
-          #"~" => "-" ^ String.extract (s, 1, NONE)
-        | _ => s
-    end;
-
-(*
-To align with the js backend inf and nan is rewritten
-- `nan` -> `NaN`
-- `inf` -> `Infinity`
-- `~2.1` -> `-2.1`
-They do still disagree on the truncating of `2.0` to `2` (ml does not).
-*)
-fun show'real x =
-    let val s = (Real.toString x) in
-    case s of
-          "nan" => "NaN"
-        | "inf" => "Infinity"
-        | _ => case String.sub (s, 0) of
-              #"~" => "-" ^ String.extract (s, 1, NONE)
-            | _ => s
-    end;
-
-fun show'unit x = ""
-
-fun show'bool x = Bool.toString x
-
-fun show'string x = x
-
-(* TIMING *)
-val mlStartTime = Time.toMilliseconds (Time.now ());
-
-(* RANDOM *)
-fun mlRandomReal () =
-   let
-      val r = MLton.Random.rand ();
-      val rreal = MLton.Real.fromWord r;
-      val wsize = Real.fromInt Word.wordSize;
-      fun shiftRight r shift = r / (Math.pow(2.0, shift))
-   in
-      shiftRight rreal wsize
-   end;
-
-(* HOLES *)
-exception Hole
-
-exception Absurd

package/libraries/ml/internal/mllist.effekt

@@ -1,9 +0,0 @@
-module internal/mllist
-
-extern type MLList[Elem] // = 'elem list
-extern pure def isEmpty[A](l: MLList[A]): Bool = ml "null ${l}"
-extern pure def head[A](l: MLList[A]): A = ml "hd ${l}"
-extern pure def tail[A](l: MLList[A]): MLList[A] = ml "tl ${l}"
-
-def toList[A](l: MLList[A]): List[A] =
-  if (l.isEmpty) Nil() else Cons(l.head, toList(l.tail))

package/libraries/ml/internal/mloption.effekt

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

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 = ml "Random.rand (${n}, ${m})"
-extern pure def toString(s: RNG): String = ml "Random.toString ${s}"
-
-extern io def int(s: RNG): Int = ml "Random.randInt ${s}"
-extern io def int(s: RNG, from: Int, to: Int): Int = ml "Random.randRange (${from}, ${to}) ${s}"
-extern io def double(s: RNG): Double = ml "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 =
-  ml "Rand.random ${s}"
-extern pure def range(s: PseudoRNG, n: Int, m: Int): Int =
-  ml "Rand.range (${n}, ${m}) ${s}"
-extern pure def norm(s: PseudoRNG): Double =
-  ml "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 =
-  ml "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/text/regex.effekt

@@ -1,102 +0,0 @@
-module text/regex
-
-import internal/mllist
-import internal/mloption
-
-extern type Char // TODO move to text/string
-type Chars = MLList[Char]
-
-
-extern pure def chars(str: String): Chars = ml "String.explode ${str}"
-extern pure def toString(chars: Chars): String = ml "String.implode ${chars}"
-
-extern ml """
-
-(** 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 =
-  ml "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 ml """
-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 =
-  ml "matchedString ${result}"
-extern pure def getRemainder(result: MLMatchResult): Chars =
-  ml "remainderChars ${result}"
-
-extern pure def unsafeSplit(str: String, ch: Char): MLList[String] =
-  ml "String.fields (fn c => c = ${ch}) ${str}"
-
-extern pure def unsafeMatchPrefix(r: Regex, str: Chars): MLOption[MLMatchResult] =
-  ml "RegExp.prefix ${r} List.getItem ${str}"
-
-extern pure def unsafeSplit(str: String, sep: String): MLList[String] =
-  ml "unsafeSplit ${str} ${sep}"
-
-extern ml """
-val NEWLINE_CHAR = #"\n";
-"""
-
-extern pure def unsafeLines(str: String): MLList[String] =
-  ml "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() }
-}