kisp

;; MithrilJS/ospec: Noiseless testing framework
;; https://github.com/MithrilJS/ospec

;; {
;;   "devDependencies": {
;;     "ospec": "^4.2.0"
;;   }
;; }

;; Parenscript

kisp

// app/javascript/application.js

// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
import "@hotwired/turbo-rails"
import "controllers"

// Add this line
Turbo.session.linkPrefetchObserver.stop()

kisp

grep for complements

Imagine you have a CLI command cat myfile | ./my-filter, and now you want to see all the lines not selected, essentially negating my-filter. Here is a way to achieve that.

The "grep for complements" command is a useful tool for filtering out lines from a file that have not been selected by a custom filter. This can be achieved using a combination of cat, your custom filter (./my-filter), and grep.

Usage

To use "grep for complements", follow these steps:

kisp

/*
You can run this file with

maxima -b cosine-rule.mac

or maybe also using M-x quickrun
*/

/*

kisp

;; Note: This is a work in progress
;;
;; A function (cart-prod a b) is developed here that computes the cartesian
;; product of two lists.
;;
;; For example:
;;
;; (cart-prod '(1 2 3) '(a b)) => ((1 a) (1 b) (2 a) (2 b) (3 a) (3 b))
;;
;; The function cart-prod is proven sound and complete by the theorems

kisp

;; -*- mode: lisp; -*- ;; (ql:quickload "screamer")

(in-package :screamer-user)

;; SmallCheck and Lazy SmallCheck - automatic exhaustive testing for small values
;; https://www.cs.york.ac.uk/fp/smallcheck/smallcheck.pdf

(defun an-integer-upto-depth (depth)
  (either
    0

kisp

;;; The following code implements the conversion of a natural number
;;; to a list of digits and back.

;;; ACL2 Version 8.5
;;; https://www.cs.utexas.edu/users/moore/acl2/

;;; ACL2 is used to prove that one conversion followed by the other
;;; leads back to the initial value (roundtrip).  This is proved in
;;; both directions:
;;; starting from a natural number (see main/base10-representation-1

kisp

(in-package :cl-user)

;;; destructuring-match
;;;
;;; Really simple implementation of pattern matching with multiple
;;; clauses for Common Lisp (using one implementation detail of SBCL
;;; here, namely sb-kernel::defmacro-lambda-list-bind-error).
;;;
;;; Like a combination of destructuring-bind and case.
;;;

kisp

(in-package :cl-user)

;; (ql:quickload '("alexandria" "trivia"))

;; Let's define maybe as an algebraic data type.
(defstruct (nothing (:constructor nothing ())))
(defstruct (just (:constructor just (value))) value)
(deftype maybe () '(or nothing just))

;; (>>=) :: Monad m => m a -> (a -> m b) -> m b

kisp

#!/bin/bash

set -euxo pipefail

cd "$(dirname "$0")"

export UNISON=$(pwd)/.unison

mkdir -p "$UNISON"