scheduling.effekt

module reactive/interleave

import immutable/option
import reactive/types
import reactive/effects

def interleave[T1, T2, R]{ task1: => T1 / Scheduling } {task2: => T2 / Scheduling } {loop: {() => Option[T1]}{() => Option[T2]} => R }: R = region this {
    var p1: => Option[T1] at {this, task1} in this = fun(){None()}
    var p2: => Option[T2] at {this, task2} in this = fun(){None()}
    
    p1 = fun(){
        try {
            val t = Some(task1())
            p1 = fun(){t}
            t  
        } with Scheduling {
            def tick() = {p1 = fun(){ resume(()) }; None()}
        }
    }

    p2 = fun(){
        try {
            val t = Some(task2())
            p2 = fun(){t}
            t
        } with Scheduling {
            def tick() = {p2 = fun(){ resume(()) }; None()}
        }
    }

    loop{() => p1()}{() => p2()}
}

def bothAreDone[T1, T2] {task1: => T1 / Scheduling} {task2: => T2 / Scheduling}: Tuple2[T1, T2]  / Scheduling = {
    def loop{p1: => Option[T1]}{p2: => Option[T2]}: Tuple2[T1, T2] = {
        (p1(), p2()) match {
            case (Some(t1), Some(t2)) => do tick(); Tuple2(t1, t2)
            case (_,_) => do tick(); loop{p1}{p2}
        }
    }
    interleave{task1}{task2}{loop}
}

def oneIsDone[T1, T2]{ task1: => T1 / Scheduling } {task2: => T2 / Scheduling }: Either[T1, T2] / Scheduling = {
    def loop{p1: => Option[T1]} {p2: => Option[T2]}: Either[T1, T2]  = {
        p1() match {
            case Some(t1) => do tick(); Left(t1)
            case None() => p2() match {
                case Some(t2) => do tick(); Right(t2)
                case None() => do tick(); loop{p1}{p2}
            }
        }
    }
    interleave{task1}{task2}{loop}
}

def forever[T] { task: => T / Scheduling }: Nothing / Scheduling = try {
    task()
    forever { task }
} with Scheduling {
    def tick() = { do tick(); resume(())}
} 

def run[T]{task: => T / { Scheduling, Exception[ReactiveError] }}: Unit = {
    try{
        task()
        println("") // Needed bug report.
    } with Scheduling {
       def tick() = resume(())
    } with Exception[ReactiveError] {
        def raise[ReactiveError](e, msg) = println(msg) 
    }
}