Heimdell

use std::sync::Arc;

enum Octree<B, A>
  { Branch
      { preview  : B
      , subtrees : [Arc<Octree<B, A>>; 8]
      }
  , Atom
      { leaf    : A

Heimdell

{- | A chunk of 16x16x16 atoms.
-}

module Chunk where

import Prelude hiding (read)

import Control.Monad
import Control.Monad.Primitive

Heimdell

module Union where

import Control.Monad
import qualified Control.Monad.Reader as MTL

data Union fs (m :: * -> *) x where
  Here  :: f m x -> Union (f : fs) m x
  There :: Union fs m x -> Union (f : fs) m x

Heimdell

module AST where

import Data.Constraint
import Data.Functor.Compose
import Data.Fix
import Data.Text (Text)
import qualified Data.Text as Text

import GHC.TypeLits

Heimdell

{-# language DataKinds              #-}
{-# language DerivingStrategies     #-}
{-# language DeriveFunctor          #-}
{-# language FlexibleContexts       #-}
{-# language FlexibleInstances      #-}
{-# language FunctionalDependencies #-}
{-# language GADTs                  #-}
{-# language KindSignatures         #-}
{-# language MultiParamTypeClasses  #-}
{-# language ScopedTypeVariables    #-}

Heimdell

module Weld where

import Control.Arrow

import Data.Bifunctor as B

import Text.PrettyPrint as PP hiding ((<>))

infix 1 \/

Heimdell

module Optics.Core exposing
  ( Optic
  , id
  , o
  
  , lens
  , prism
  , traversal

  , view

Heimdell

{-# language LambdaCase #-}
{-# language BlockArguments #-}
{-# language GADTs #-}
{-# language DataKinds #-}
{-# language TypeApplications #-}
{-# language DuplicateRecordFields #-}

{-|

Heimdell

module type FUNCTOR = sig
  type 'a t
  val map : ('a -> 'b) -> 'a t -> 'b t
end

module type APPLY = sig
  include FUNCTOR
  val ap : ('a -> 'b) t -> 'a t -> 'b t
end

Heimdell

{- | The union of functors and utilities.

-}

module Union
  ( -- * Union type
    Union(..)
  , eliminate