harpocrates

Given a collection of elements X, a sharding function should map every element of X into a shard.

trait Sharder[X] {
  /// The final output must always be in the range [0, totalShards-1], hopefully evenly distributed in that range.
  def apply(totalShards: Int): X => Int
}

Note that we have to fix the number of shards we want before getting our sharding function. One thing we may want is to change the number of shards. When we do this, it is expected that a bunch of x: X will now map to new shards. Depending on how we intend to change the number of shards, we can be clever about defining Sharder[X] so as to minimize the number of x: X which move to a new shard.

harpocrates

 {-# LANGUAGE RankNTypes, ScopedTypeVariables, TypeApplications, ConstraintKinds #-}
 module Main where

 import Data.Constraint
 import Unsafe.Coerce

 newtype MyInt = MyInt Int
 instance Eq MyInt where { _ == _ = True }

 flip' :: forall a b. Dict (Eq a, Eq b) -> a -> a -> Bool

harpocrates

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DeriveFunctor #-}

harpocrates

\documentclass{article}
\usepackage{amsfonts}
\usepackage{amsmath}
\title{Feynmann's integral trick}
\date{August 2018}
\begin{document}
\maketitle

The trick is to define a new function $I \colon \mathbb{R} \to \mathbb{R}$ such that $I(a_0)$ is the
integral we are trying to evaluate and $I(a_1)$ reduces to something more easily evaluated. The next

harpocrates

#![feature(fn_traits)]
#![feature(unboxed_closures)]

/// Wrapper around Haskell function. Note this _cannot_ be copied/cloned
#[repr(C)]
pub struct HaskellFn1<A,B>(extern "C" fn(A) -> B);

/// Closure behaviour
impl<A,B> FnOnce<A> for HaskellFn1<A,B> {
    type Output = B;

harpocrates

{-# LANGUAGE FlexibleInstances #-}

-- Get the truth-table of a function which operates over any number of 'Bool'
-- inputs and has a `Bool` output `Bool`.

class TruthTable b where
  truthtable :: b -> [([Bool], Bool)]

instance TruthTable Bool where
  truthtable b = [([],b)]

harpocrates

{-# OPTIONS_GHC -w #-}
{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}
{-# OPTIONS_GHC -XPartialTypeSignatures #-}
module Main (
  parseTerm, parseSentence, parseEditList, main
) where
import Data.Foldable (toList)
import Data.List.NonEmpty (NonEmpty(..), (<|))
import qualified Data.List.NonEmpty as NEL
import qualified Data.Array as Happy_Data_Array

harpocrates

-- Notice how flipping the order of anything makes this not
-- compile - this demonstrates that GHC is doing the following
-- in order:
-- 
--  1. Processing the `foo` declaration
--  2. Processing the `bar` declaration
--  3. Processing the `baz` declaration
--
-- So GHC is already doing multiple passes, right?

harpocrates

{-# LANGUAGE
      FlexibleInstances, FlexibleContexts, UndecidableInstances,
      TypeFamilies, DataKinds, GADTs, ConstraintKinds, TypeOperators,
      MultiParamTypeClasses, FunctionalDependencies 
  #-}

module VarArgs (
  -- * Core
  Args(..), args,
  -- * Utility

harpocrates

{-# LANGUAGE TypeFamilies #-}

import Data.Void

class Foo k where
  data Bar k
  
instance {-# OVERLAPPING #-} Foo () where
  data Bar () = UnitBar Void