evincarofautumn

{-# Language
    BlockArguments,
    DataKinds,
    DerivingStrategies,
    GADTs,
    InstanceSigs,
    LambdaCase,
    PatternSynonyms,
    PolyKinds,
    RankNTypes,

evincarofautumn

{-# LANGUAGE GADTs                #-}
{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE RankNTypes           #-}
{-# LANGUAGE PolyKinds            #-}

module STLC where

-- Defining type and the corresponding singletons

evincarofautumn

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}

import Data.Function (fix)
import Data.IORef

-- INPUT: void M(ICounter)
-- Usage: m intCounter
m :: ICounter -> IO ()

evincarofautumn

-_

trait debug<T> (T -> debug::Repr);

about debug<T>:
  kitten::docs:
    """
    Produce a debugging representation (`debug::Repr`) of a value.

    For uninspectable types such as functions, use `debug::opaque`.

evincarofautumn

Programming Language Idea Shelter

This is a list of notations and semantics I’ve wanted to use or have used in toy programming languages that I think are particularly nice but rare, and that I’d like to see in more languages. If you’re a PL dev and you fall in love with one, adopt it and let me know!

Unary Relational Range Operators

Most languages use the standard relational operators for comparisons (>, <, ≥/>=, ≤/<=/=<, =/==/===, ≠/!=//=/<>), but these are almost always presented as binary operators for comparing two values. Some languages (of which Python is the most notable) include “chained” comparisons like a <= b < c, meaning a <= b and b < c (but with b only evaluated for its side effects once, that is, (lambda x: a <= x and x < c)(b)). Some languages also allow unary versions of these operators, but they rarely denote anything related to comparisons. Some languages such as Haskell allow arguments to be omitted from operators via operator sections, denot

evincarofautumn

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

evincarofautumn

// Uninhabited type, value-kinded
type Void {}
// or:
// type synonym Void as type (VOID);

// Uninhabited type, poly-kinded
type VOID<K> as K {}
// or (wibbles):
// type VOID as <K> K {}
// type<K> VOID as K {}

evincarofautumn

#include <iostream>
#include <optional>
#include <vector>
using namespace std;

template<template<typename A> typename F>
struct Alternative {

  template<typename A>
  static F<A> empty();

evincarofautumn

import Data.Ord (Down(..), comparing)
import Data.List (permutations, sortBy)
import Data.Maybe (listToMaybe)
import qualified Data.Set as Set

-- | A matrix of approval votes. @forall (a :: 'Approvals'). a !! i !! j@
-- is the number of approval votes that person @i@ awarded to person @j@.
type Approvals = [[Int]]

-- | List of list of indices representing a partition of a list. Invariant:

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