quephird

module Sums where

import Data.Array ((:), foldM, nub, sort)
import Data.Maybe (Maybe(..))
import Prelude (($), (+), (++), map)

-- Given an array of integers, compute the list of all
-- possible totals, using each integer at most once.

sums :: Array Int -> Maybe (Array Int)

quephird

module FilterM where

import Prelude (Monad, ($), (<), (>), (/=), bind, return)

import Data.List (List(..))
import Data.Maybe (Maybe(..))

filterM' :: forall m a. (Monad m) => (a -> m Boolean) -> List a -> List a -> m (List a)
filterM' p acc Nil = return acc
filterM' p acc (Cons x xs) = do

quephird

module Example.HelloGlsl where

import Prelude (Unit(..)
               ,($)
               ,bind)

import Control.Monad.Eff (Eff(..))
import Control.Monad.Eff.Alert (Alert(..)
                               ,alert)
import Control.Monad.Eff.Console (CONSOLE(..)

quephird

module Plot where

import Prelude (($), bind, return)

import Control.Monad.Eff (Eff(..))
import Data.List (List(..), toList)
import Data.Maybe (Maybe(..))
import Graphics.Canvas ( Canvas(..)
                       , Context2D(..)
                       , closePath

quephird

class Vehicle {
  var color: String?
  var maxSpeed = 80 {
    willSet(s) {
      print("Changing max speed from \(s)...")
    }
    didSet(s) {
      print("to \(s)")
    }
  }

quephird

import Foundation

class Vehicle {
  lazy var isWarmedUp: Bool = self.start()
  var color: String?
  var maxSpeed = 80 {
    willSet(s) {
      print("Changing max speed from \(s)...")
    }
    didSet(s) {

quephird

Utilities

Launchy	right-aligned
RapidEE	http://www.rapidee.com/en/about
WinDirStat	https://windirstat.info/

Drawing/image editing

quephird

#version 3.7;
global_settings { assumed_gamma 1.0 }

#include "colors.inc"
#include "glass.inc"          
#include "textures.inc"

                                
// Random color generator with moving seed
#declare My_seed = seed(now * 100000);    

quephird

(defn solution [big-string]
  (->> big-string
    (clojure.string/split-lines)                           ; Break string into individual numbers
    (map reverse)                                          ; Reverse the digits in each
    (map (fn [n] (map #(Integer/parseInt (str %)) n)))     ; Turn all characters into actual ints
    (apply map +)                                          ; Sum each column of digits
    (reduce (fn [[digits carry] n]                         ; Fold over the partial sums,
              [(conj digits (rem (+ n carry) 10))          ;   adding the current sum modulo ten to the list of digits
               (quot (+ n carry) 10)]) [() 0])             ;   and taking the quotient over ten as the carry
    ((fn [[digits carry]] (str carry (apply str digits)))) ; Convert back to a single string, last carry at the front.

quephird

(ns ellipses
  (:require [quil.core :as q :include-macros true]
            [quil.middleware :as m]))

(defn setup []
  (q/background 0)
  (q/stroke-weight 0.25)
  (q/no-fill)
  (q/color-mode :hsb)
  (q/no-loop))