@effekt-lang/effekt 0.2.2 → 0.3.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@effekt-lang/effekt",
   "author": "Jonathan Brachthäuser",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/effekt-lang/effekt.git"
   },
-  "description": "A language with effects and handlers",
+  "description": "A language with lexical effect handlers and lightweight effect polymorphism",
   "main": "index.js",
   "scripts": {},
   "bin": {

package/libraries/chez/callcc/effekt.effekt

@@ -1,221 +0,0 @@
-module effekt
-
-// shift-0 based implementation
-extern include "../common/effekt_primitives.ss"
-// extern include "datatype.ss"
-extern include "seq0.ss"
-extern include "tail0.ss"
-extern include "effekt.ss"
-extern include "../common/effekt_matching.ss"
-
-
-def locally[R] { f: => R }: R = f()
-
-// String ops
-// ==========
-extern pure def infixConcat(s1: String, s2: String): String =
-  "(string-append ${s1} ${s2})"
-
-// TODO implement
-extern pure def show[R](value: R): String =
-  "(show_impl ${value})"
-
-extern io def println[R](r: R): Unit =
-  "(println_impl ${r})"
-
-extern io def error[R](msg: String): R =
-  "(raise ${msg})"
-
-extern io def random(): Double =
-  "(random 1.0)"
-
-// Math ops
-// ========
-extern pure def infixAdd(x: Int, y: Int): Int =
-  "(+ ${x} ${y})"
-
-extern pure def infixMul(x: Int, y: Int): Int =
-  "(* ${x} ${y})"
-
-extern pure def infixDiv(x: Int, y: Int): Int =
-  "(floor (/ ${x} ${y}))"
-
-extern pure def infixSub(x: Int, y: Int): Int =
-  "(- ${x} ${y})"
-
-extern pure def mod(x: Int, y: Int): Int =
-  "(modulo ${x} ${y})"
-
-extern pure def infixAdd(x: Double, y: Double): Double =
-  "(+ ${x} ${y})"
-
-extern pure def infixMul(x: Double, y: Double): Double =
-  "(* ${x} ${y})"
-
-extern pure def infixDiv(x: Double, y: Double): Double =
-  "(/ ${x} ${y})"
-
-extern pure def infixSub(x: Double, y: Double): Double =
-  "(- ${x} ${y})"
-
-extern pure def cos(x: Double): Double =
-  "(cos ${x})"
-
-extern pure def sin(x: Double): Double =
-  "(sin ${x})"
-
-extern pure def atan(x: Double): Double =
-  "(atan ${x})"
-
-extern pure def tan(x: Double): Double =
-  "(tan ${x})"
-
-extern pure def sqrt(x: Double): Double =
-  "(sqrt ${x})"
-
-extern pure def square(x: Double): Double =
-  "(* ${x} ${x})"
-
-extern pure def log(x: Double): Double =
-  "(log ${x})"
-
-extern pure def log1p(x: Double): Double =
-  "(log (+ ${x} 1))"
-
-extern pure def exp(x: Double): Double =
-  "(exp ${x})"
-
-// since we do not have "extern val", yet
-extern pure def _pi(): Double =
-  "(* 4 (atan 1))"
-
-val PI: Double = _pi()
-
-extern pure def toInt(d: Double): Int =
-  "(round ${d})"
-
-extern pure def toDouble(d: Int): Double =
-  "${d}"
-
-def min(n: Int, m: Int): Int =
-    if (n < m) n else m
-
-def max(n: Int, m: Int): Int =
-    if (n > m) n else m
-
-// Comparison ops
-// ==============
-extern pure def infixEq[R](x: R, y: R): Boolean =
-  "(equal_impl ${x} ${y})"
-
-extern pure def infixNeq[R](x: R, y: R): Boolean =
-  "(not (equal_impl ${x} ${y}))"
-
-extern pure def infixLt(x: Int, y: Int): Boolean =
-  "(< ${x} ${y})"
-
-extern pure def infixLte(x: Int, y: Int): Boolean =
-  "(<= ${x} ${y})"
-
-extern pure def infixGt(x: Int, y: Int): Boolean =
-  "(> ${x} ${y})"
-
-extern pure def infixGte(x: Int, y: Int): Boolean =
-  "(>= ${x} ${y})"
-
-extern pure def infixLt(x: Double, y: Double): Boolean =
-  "(< ${x} ${y})"
-
-extern pure def infixLte(x: Double, y: Double): Boolean =
-  "(<= ${x} ${y})"
-
-extern pure def infixGt(x: Double, y: Double): Boolean =
-  "(> ${x} ${y})"
-
-extern pure def infixGte(x: Double, y: Double): Boolean =
-  "(>= ${x} ${y})"
-
-// Boolean ops
-// ===========
-// for now those are considered eager
-extern pure def not(b: Boolean): Boolean =
-  "(not ${b})"
-
-extern pure def infixOr(x: Boolean, y: Boolean): Boolean =
-  "(or ${x} ${y})"
-
-extern pure def infixAnd(x: Boolean, y: Boolean): Boolean =
-  "(and ${x} ${y})"
-
-// Should only be used internally since values in Effekt should not be undefined
-extern pure def isUndefined[A](value: A): Boolean =
-  "(eq? ${value} #f)"
-
-// Pairs
-// =====
-record Tuple2[A, B](first: A, second: B)
-record Tuple3[A, B, C](first: A, second: B, third: C)
-record Tuple4[A, B, C, D](first: A, second: B, third: C, fourth: D)
-record Tuple5[A, B, C, D, E](first: A, second: B, third: C, fourth: D, fifth: E)
-record Tuple6[A, B, C, D, E, F](first: A, second: B, third: C, fourth: D, fifth: E, sixth: F)
-
-// Exceptions
-// ==========
-// a fatal runtime error that cannot be caught
-extern io def panic[R](msg: String): R =
-  "(raise ${msg})"
-
-interface Exception[E] {
-  def raise(exception: E, msg: String): Nothing
-}
-record RuntimeError()
-
-def raise[A](msg: String): A / Exception[RuntimeError] = do raise(RuntimeError(), msg) match {}
-def raise[A, E](exception: E, msg: String): A / Exception[E] = do raise(exception, msg) match {}
-
-// converts exceptions of (static) type E to an uncatchable panic that aborts the program
-def panicOn[E] { prog: => Unit / Exception[E] }: Unit =
-  try { prog() } with Exception[E] { def raise(exception: E, msg: String) = panic(msg) }
-
-// reports exceptions of (static) type E to the console
-def report[E] { prog: => Unit / Exception[E] }: Unit =
-  try { prog() } with Exception[E] { def raise(exception: E, msg: String) = println(msg) }
-
-// ignores exceptions of (static) type E
-// TODO this should be called "ignore" but that name currently clashes with internal pattern matching names on $effekt
-def ignoring[E] { prog: => Unit / Exception[E] }: Unit =
-  try { prog() } with Exception[E] { def raise(exception: E, msg: String) = () }
-
-// Control Flow
-// ============
-interface Control {
-  def break(): Unit
-  def continue(): Unit
-}
-
-def loop { f: () => Unit / Control }: Unit = try {
-  def go(): Unit = { f(); go() }
-  go()
-} with Control {
-  def break() = ()
-  def continue() = loop { f }
-}
-
-/**
- * Calls provided action repeatedly. `start` is inclusive, `end` is not.
- */
-def each(start: Int, end: Int) { action: (Int) => Unit / Control } = {
-  var i = start;
-  loop {
-    if (i < end) { val el = i; i = i + 1; action(el) }
-    else { do break() }
-  }
-}
-
-def repeat(n: Int) { action: () => Unit / Control } = each(0, n) { n => action() }
-
-// Benchmarking
-// ============
-// should only be used with pure blocks
-extern control def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit =
-  "(display (measure ${box block} ${warmup} ${iterations}))"

package/libraries/chez/common/effekt_matching.ss

@@ -1,100 +0,0 @@
-; Matcher = (SCRUTINEE, ANS -> () -> R, () -> R, (ANS -> () -> R) -> R) -> R
-
-(define done (lambda (matched) (matched)))
-
-(define (any m matched failed k)
-  (k (matched m)))
-
-(define (ignore m matched failed k)
-  (k matched))
-
-(define (literal l)
-  (lambda (m matched failed k)
-    (if (equal_impl m l)
-        (k matched)
-        (failed))))
-
-(define (bind p)
-  (lambda (m matched failed k)
-    (p m (matched m) failed k)))
-
-;; for this record
-; (define-record Pair (fst snd))
-
-;; this is what we need to generate
-; (define (match-Pair p1 p2)
-;   (lambda (m matched failed k)
-;     (if (Pair? m)
-;       (p1 (Pair-fst m) matched failed (lambda (matched)
-;         (p2 (Pair-snd m) matched failed k)))
-;       (failed))))
-
-
-(define-syntax define-matcher
-  (syntax-rules ()
-    [(_ name pred ())
-      (define (name)
-        (lambda (sc matched failed k)
-          (if (pred sc) (k matched) (failed))))]
-    [(_ name pred ((p1 sel1) (p2 sel2) ...))
-     (define (name p1 p2 ...)
-       (lambda (m matched failed k)
-             ;; has correct tag?
-             (if (pred m)
-                 (match-fields m matched failed k ([p1 sel1] [p2 sel2] ...))
-                 (failed))))]))
-
-(define-syntax match-fields
-  (syntax-rules ()
-    [(_ m matched failed k ()) (k matched)]
-    [(_ m matched failed k ([p1 sel1] [p2 sel2] ...))
-     (p1 (sel1 m) matched failed (lambda (matched)
-       (match-fields m matched failed k ([p2 sel2] ...))))]))
-
-
-; forces the pattern match
-(define-syntax pattern-match
-  (syntax-rules ()
-    [(_ m ()) (raise "no patterns provided")]
-    [(_ m ([p1 k1] [p2 k2]...))
-      (p1 m k1 (lambda () (pattern-match m ([p2 k2] ...))) done)]))
-
-;; Examples
-
-; (define-matcher match-Pair2 Pair? ([p1 Pair-fst] [p2 Pair-snd]))
-
-; (define (match sc p matched)
-;   (p sc matched abort done))
-
-; (display (match (make-Pair 1 2)
-;   (match-Pair2 any any)
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match 3
-;   (match-Pair2 any any)
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match (make-Pair 1 2)
-;   (match-Pair2 any (match-Pair2 ignore any))
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match (make-Pair 1 (make-Pair 2 3))
-;   (match-Pair2 any (match-Pair2 ignore any))
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match (make-Pair (make-Pair 1 2) (make-Pair 3 4))
-;   (match-Pair (match-Pair ignore any) (match-Pair ignore any))
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match (make-Pair (make-Pair 1 2) (make-Pair 10 15))
-;   (match-Pair2 (match-Pair2 any ignore) (match-Pair2 ignore any))
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (match (make-Pair (make-Pair 1 2) (make-Pair 10 15))
-;   (match-Pair2 (match-Pair2 any ignore) (match-Pair2 ignore any))
-;   (lambda (x) (lambda (y) (lambda () (+ x y))))))
-
-; (display (pattern-match (make-Pair 1 2)
-;   ([(match-Pair2 (match-Pair2 any ignore) (match-Pair2 ignore any))
-;       (lambda (x) (lambda (y) (lambda () (+ x y))))]
-;    [any (lambda (x) (lambda () (Pair-snd x)))])))