sjolsen

import collections
import dataclasses
import sys
from typing import Iterable, Self


IGNORED_WORDS: frozenset[str] = frozenset([
    'adv',
    'dis',
    'eds',

sjolsen

(defclass callable-class (standard-class function)
  ()
  (:metaclass sb-mop:funcallable-standard-class))

(defmethod sb-mop:validate-superclass ((class callable-class) superclass)
  (or (typep superclass 'callable-class)
      (typep superclass 'standard-class)))

(defmethod initialize-instance :after ((class callable-class) &rest rest &key &allow-other-keys)
  (declare (ignore rest))

sjolsen

import apt
import networkx as nx


def is_root(pkg: apt.package.Package) -> bool:
    if not pkg.is_installed:
        return False
    if not pkg.is_auto_installed:
        return True
    if pkg.essential:

sjolsen

module Grammar where
  open import Category.Applicative
  open import Data.Char using (Char)
  open import Data.List using (List)
  open import Data.List.NonEmpty using (List⁺; map; foldl₁; fromList)
  open import Data.Maybe using (from-just)
  open import Data.Nat using (ℕ; _+_; _*_)
  open import Data.String using (String; toList)
  open import Data.Unit
  open import Function

sjolsen

sjolsen

import sys
from typing import FrozenSet, Iterable, Iterator, List, NamedTuple, NewType, Sequence, Set

from frozendict import frozendict
from multiset import FrozenMultiset

# Text munging

def normalize(s: str) -> str:
    return ''.join(c.lower() for c in s if c.isalnum())            

sjolsen

use futures::executor::*;
use futures::future::*;
use futures::task::*;
use futures_util::pin_mut;
use std::pin::*;

async fn use_me(i: i32) -> i32 {
    i
}

sjolsen

#include <charconv>
#include <iostream>
#include <string>
#include <system_error>

std::string to_hex(uint64_t val) {
  char buf[16];
  auto [end, e] = std::to_chars(std::begin(buf), std::end(buf), val, 16);
  if (e != std::errc()) {
    throw std::system_error(std::make_error_code(e));

sjolsen

open import Level using () renaming (suc to lsuc)
open import Data.Empty
open import Data.Nat hiding (compare)
open import Data.Nat.Properties
open import Data.Product
open import Data.Sum
open import Data.Vec
open import Function
open import Relation.Nullary
open import Relation.Nullary.Negation

sjolsen

import Control.Monad
import Data.Functor

data Free f a = Unit a | Join (f (Free f a))

runMonad :: Functor f => (a -> f a) -> (f (f a) -> f a) -> Free f a -> f a
runMonad unit join (Unit x) = unit x
runMonad unit join (Join x) = join (runMonad unit join <$> x)

runMonad' :: (Functor m, Monad m) => Free m a -> m a