hackwaly

type ('a, 'b) tree =
  | Empty
  | Node of
      { left : ('a, 'b) tree
      ; right : ('a, 'b) tree
      ; key : 'a
      ; value : 'b
      ; height : int
      }

hackwaly

(* HAMT v.s. AVL benchmark.

   test for their usage as string map.

   usage:
   > ocamlopt HAMT.ml -o <executable-name>
   > <executable-name> (avl|hamt) (random|ordered) <key-length>

   time data of the form:
     <tree-size> <add-time> <find-time>

hackwaly

(library
 (name ppx_poly_gadt)
 (kind ppx_rewriter)
 (preprocess
  (pps ppxlib.metaquot))
 (libraries ppxlib))

hackwaly

let dummy_arr = [||];

module type ELT = {
  type t;

  let uninitialized: t;
};

module Make = (Elt: ELT) => {
  type t('a) = {

hackwaly

type ('data, 'index) node =
  { left : ('data, 'index) node option
  ; right : ('data, 'index) node option
  ; priority : int
  ; mutable data : 'data
  ; mutable index : 'index
  }

type ('a, 'b) t = ('a, 'b) node option

hackwaly

module type TERM = sig
  type t
  type tvar
  val var_opt : t -> tvar option
  val compare_var : tvar -> tvar -> int
  val same_functor : t -> t -> bool
  val args : t -> t list
end

module Make (Term : TERM) = struct

hackwaly

(* Doubly linked list *)

type 'a node = { mutable prev : 'a node; mutable next : 'a node; data : 'a }
type 'a list = List of 'a node [@@unboxed]

let create () =
  let rec root = { prev = root; next = root; data = Obj.magic `Dummy } in
  List root

let iter (List root) f =

hackwaly

import { assert } from "./Errors";

export type treap<a, b> = node<a, b> | undefined;

export type node<a, b> = {
  left: treap<a, b>;
  right: treap<a, b>;
  priority: number;
  data: a;
  subtreeData: b;

hackwaly

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as Caml_array from "rescript/lib/es6/caml_array.js";

function cons(_record, _map) {
  while(true) {
    var map = _map;
    var record = _record;
    if (!map) {
      return {

hackwaly

enum Color {
  RED,
  BLACK
}

class Node {
  public parent: Node;
  public left: Node;
  public right: Node;