derrickturk

{-# LANGUAGE DataKinds, GADTs, KindSignatures, TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}

module Data.HList
  ( HList(..)
  , TypeMap
  ) where

import Data.Kind (Type)
import Data.Maybe (fromJust, fromMaybe)

derrickturk

base26 :: Integer -> String
base26 n =
  let (m, n') = n `divMod` 26
      ones = [toEnum (fromEnum 'A' + fromInteger n')]
   in case m of
     0 -> ones
     m -> base26 (m - 1) ++ ones

derrickturk

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>

typedef struct node {
    int value;
    struct node *next;
} node, *list;

void list_free(list l)

derrickturk

use "collections"

interface Sendable
  fun tag send(word: I64)

primitive Running
primitive Blocked
primitive Halted
primitive IllegalInstruction

derrickturk

abstract type meat
  Beef
  pub Lamb(age: int)

derrickturk

fun iota_vec(n: int): vector<int>
  vector-init(n, id)

fun oddity(n: int): exn vector<int>
  var v := iota_vec(n)
  for(0, n) fn(i)
    v[i] := v[i] + 3
  v

fun space-oddity(n: int): exn vector<int>

derrickturk

open type openvar
  A
  B

extend type openvar
  C

fun do_it_try_it(v: openvar): console ()
  match v
    A -> println("got an A")

derrickturk

derrickturk

(* yeah, so, Eff doesn't actually support polymorphic effects *)

effect Save: string -> int
effect Load: string * int -> empty

let save name = perform (Save name)
let load name v = absurd (perform (Load (name, v)))

let savegames = handler
  | effect (Save name) k ->

derrickturk

effect QuickSave: int option
effect QuickLoad: int -> empty

let quicksave () = perform QuickSave
let quickload n = absurd (perform (QuickLoad n))

let quicksaving = handler
  | effect QuickSave k ->
      let rec quickloading () = handler
        | effect (QuickLoad n) _ ->