Lucifier129

// data version

type DraftPost = {
  kind: 'DraftPost';
  content: string;
};

type ReviewingPost = {
  kind: 'ReviewingPost';
  content: string;

Lucifier129

export const fetch = (url, options = {}) => {
  let { fetch = globalThis.fetch, ...restOptions } = options;

  if (typeof fetch !== 'function') {
    throw new Error(`Expected fetch to be a function, but received ${fetch}`);
  }

  let finalUrl = url;
  
  let finalOptions = {

Lucifier129

type State = {
  count: number;
};

type ActionVisitor = {
  incre: (step: number) => State;
  decre: (step: number) => State;
};

type Action = {

Lucifier129

// option type
interface OptionVisitor<A, B> {
  None: () => B;
  Some: (a: A) => B;
}

type OptionData<A> =
  | {
      kind: 'None';
    }

Lucifier129

let identity = x => x
let createBF = (getChildren) => {
  let handler = (stack = [], results = [], f) => {
    if (stack.length === 0) return results;
    let [head, ...tail] = stack;
    let nextStack = tail.concat(getChildren(head));
    return handler(nextStack, [...results, f(head)], f);
  };
  return (tree, f = identity) => handler([tree], [], f);
};

Lucifier129

const createTreeModule = (operations) => {
  const append = (tree, node) => {
    if (operations.matchChild(tree, node)) {
      return operations.appendChild(tree, node);
    }
    return operations.map(tree, (child) => {
      return append(child, node);
    });
  };

Lucifier129

let run = (f, handlers) => {
  try {
    return f();
  } catch (effect) {
    if (effect.type in handlers) {
      handlers[effect.type](effect.payload, effect.continuation);
    } else {
        throw effect
    }
  }

Lucifier129

const createOperation = name => (...args) => {
  let operation = interpreter =>
    interpreter[name](
      ...args.map(f => (f && f.operation ? f(interpreter) : f))
    );
  operation.operation = true;
  return operation;
};

const createOperations = (...names) =>

Lucifier129

module Parser where

import Prelude (($), (<>), (==), (>=), (<=), (&&), (/=), (||), (>>>), negate)
import Data.Show (class Show, show)
import Data.Tuple (Tuple(..))
import Data.Either (Either(..))
import Data.Array ((:), intercalate)
import Data.Foldable (foldl, foldr)
import Data.Maybe (Maybe(..))
import Data.String (codePointAt)

Lucifier129

type result('a, 'b) =
  | Ok('a)
  | Error('b)

let inject = value => input => (Ok(value), input)

let error = e => input => (Error(e), input)

let item = input => {
  let (index, source) = input