Heimdell

module Context
    ( T()
    , empty
    , add
    , extend, singleton
    , assign, assignment
    , apply, accumulate
    )
    where

Heimdell

import Control.Monad (when)

import Data.Foldable (for_)

import System.Directory (doesDirectoryExist, doesFileExist, listDirectory)
import System.FilePath ((</>), takeExtension)
import System.Environment (getArgs)

inode dirAction fileAction = go

Heimdell

Syntax

Elements

Constants

Numbers

Just regular numbers, like

Heimdell

package main

import (
	"fmt"
	"image/color"
)

/*
	The idea is to make "better minecraft", essentially.

Heimdell

% Type variable.
%
tvar(A)         :- var(A).

% Type application.
%
% The `forall` is forbidden as constructor name, arglist must be non-empty.
%
tapp(FX, F, Xs) :- FX =.. [F | Xs], F \= forall, F \= prod, F \= sum, Xs \= [].

Heimdell

{-# language GeneralizedNewtypeDeriving #-}
{-# language DeriveFunctor #-}
{-# language LambdaCase #-}
{-# language FlexibleInstances #-}

import Control.Applicative (Alternative (..), optional)
import Control.Category ((>>>))
import Control.Monad (ap, void, guard)

Heimdell

{-# language NamedFieldPuns #-}
{-# language TypeSynonymInstances #-}
{-# language FlexibleInstances #-}
{-# language OverloadedStrings #-}
{-# language TypeFamilies #-}
{-# language LambdaCase #-}

import Control.Applicative (some)
import Control.Monad (guard, void)

Heimdell

{-# language LambdaCase #-}
{-# language TypeSynonymInstances #-}
{-# language FlexibleInstances #-}
{-# language FlexibleContexts #-}
{-# language DeriveFunctor #-}
{-# language OverloadedStrings #-}

import Control.Applicative (some)
import Control.Monad

Heimdell

// Object.prototype.ancestors = function () {
//     let acc = []
//     for (let i = this; i; i = Object.getPrototypeOf(i)) {
//         acc.push(i)
//     }
//     return acc
// }

let automatch = function (proto) {

Heimdell

/*
    Graph Reduction Machine, or GRiM.
    
    Makes it possible to implement lazy language above golang in a dumb an simple (but messy) way.
    
    The idea is a follows:
        
        Lazy program is like a makefile - its a tree (DAG) of dependent computations.
        You can freely replace each function call with its body, provided you put the arguments in places.