evincarofautumn

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE ScopedTypeVariables #-}

oneOfMany :: forall a. [Async (Maybe a)] -> IO (Either SomeException (Maybe a))
oneOfMany asyncs = loop
  where

    loop :: IO (Either SomeException (Maybe a))
    loop = do
      statuses <- for asyncs poll

evincarofautumn

rzipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
rzipWith f xs0 ys0 = loop 0 0 xs0 ys0
  where
    loop x y = curry \ case

      (_:xs, _:ys) -> loop (succ x) (succ y) xs ys

      (xs,   [])   -> done (x + length xs) y
      ([],   ys)   -> done x               (y + length ys)

evincarofautumn

-- Put some layout keyword after imports so their bodies can be formatted as blocks

import Data.Foldable where
  asum

import Control.Concurrent where
  forkIO
  threadDelay

import Control.Concurrent.STM where

evincarofautumn

A minimal esoteric language in which execution semantically proceeds in lockstep with a fixed global clock on a “grid” of instructions.

Each grid cell may contain an instruction or an extension of an instruction (for multi-stream instructions), with an optional override slot that overrides the result of the instruction (if any). All streams are zero by default, and an instruction that produces no output semantically produces zero(s).

Each instruction has a consumption, the number of streams it consumes, and a production, the number of streams it produces; its width is the maximum of its consumption and production. It’s an error to schedule an instruction with the wrong width.

A stream is only 8 bits wide; if you want multi-byte data, you must spread it across multiple streams.

Grammar

evincarofautumn

% Using integer constraint programming
:- use_module(library(clpfd)).

% Encoding the solution as a predicate
solution(Pairs, BirdPendant, WarMedal, Diamond, Ring, Vs) :-

  % List the variables to solve
  Table = [People, Colors, Places, Drinks, Heirlooms],
  Colors = [Purple, Red, Green, White, Blue],
  Places = [Dabovka, Karnaca, Baleton, Dunwall, Fraeport],

evincarofautumn

{-# LANGUAGE
  BangPatterns,
  DataKinds,
  GADTs,
  KindSignatures,
  PolyKinds,
  ScopedTypeVariables,
  TypeFamilies,
  TypeOperators #-}

evincarofautumn

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeFamilies #-}

module Main where

data Exp (p :: Phase)
  = (HasInfix p ~ 'True) => Infix (Anno p) !Op (Exp p) (Exp p)
  | (HasStack p ~ 'False) => Call (Anno p) (Exp p) (Exp p)

evincarofautumn

no stop dude literally like seriously fuck
stop no dude literally like seriously fuck
dude stop no literally like seriously fuck
stop dude no literally like seriously fuck
dude no stop literally like seriously fuck
no dude stop literally like seriously fuck
literally dude stop no like seriously fuck
dude literally stop no like seriously fuck
dude stop literally no like seriously fuck
literally stop dude no like seriously fuck

evincarofautumn

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

import Data.Functor.Identity
import Prelude hiding (Functor(..), Applicative(..), Monad(..), map)

evincarofautumn

define square_matrix_multiply
  <N as Size>
  (Array<(N * N), Float>, Array<(N * N), Float>
  -> Array<(N * N), Float>)
{
  -> left, right;

  // static::<N> lifts the value of the static constant N to runtime.
  if (static::<N> >= 256):
    512