Nymphium

#lang racket

(provide (except-out (all-defined-out) with-free Pure Free))

(require racket/control)

(struct Pure (r) #:transparent)
(struct Free (a k) #:transparent)

; (: compose [All (a b c) (-> (-> a b) (-> b c) (-> c d))])

Nymphium

#!/usr/bin/env bash

set -eu

from_date=${1:-"2024-10-01"}
to_date=${2:-"2025-03-31"}

total=0

f() {

Nymphium

local eff = require('eff')
local inst, perform, handler = eff.inst, eff.perform, eff.handler

local Twice = inst()
local Exit = inst()

--[[
co = {
  print(1)
  coroutine.yield() -- *1

Nymphium

[@@@alert "-unstable"]
[@@@warning "-32"]

(* Reimplementation of Go's worker pools using Eio and Domainslib.Chan
   https://gobyexample.com/worker-pools
 *)

module Stdenv = struct
  type _ Effect.t += Get : (Eio.Stdenv.t * Eio.Switch.t) Effect.t

Nymphium

type (_, _) operation = ..

type 'a computation =
  | Return : 'a -> 'a computation
  | Call : ('arg, 'res) operation * 'arg * ('res -> 'a computation) -> 'a computation

type ('a, 'b) handler = {
  return : 'a -> 'b computation;
  operations : 'arg 'res. ('arg, 'res) operation ->
    'arg -> ('res -> 'b computation) -> 'b computation

Nymphium

interface Get {
    readonly _tag: 'Get';
    readonly _ans: number;
}

interface Put {
    readonly _tag: 'Put';
    readonly _ans: void;
    value: number;
}

Nymphium

type (_, _) cont =
  Cont : (('a -> 'r) -> 'r) -> ('r, 'a) cont

let runCont : ('r, 'a) cont -> ('a -> 'r) -> 'r
= fun (Cont f) k -> f k

let runCont' k cf = runCont cf k

let return x = Cont((|>) x)

Nymphium

const Read = (key) => ({type : 'Read', arguments : [ key ]});
const Write = (key, value) => ({type : 'Write', arguments : [ key, value ]});

const performWith = (handler, eff) =>
    new Promise(() => { throw eff; }).catch(handler);

async function go(handler) {
  const x = await performWith(handler, Read("x"));
  await performWith(handler, Write("z", x + 4));
  const z = await performWith(handler, Read("z"));

Nymphium

module typed-delimcc

public effect subcont0<a> {
  fun shift0(f : (b -> a) -> a) : b
}

public fun reset0(th : () -> subcont0<a> a) : a {
  handle(th) {
    shift0(f) -> f(resume)
  }

Nymphium

module type NATURAL = sig
  type t

  val build : ((t -> t) -> t -> t) -> t
end

module type BUILD_NATURAL = functor
  (M : sig
     type t