philsquared

#include <cassert>
#include <iostream>

template<typename T, typename R=void>
struct ExtMethod {
    ExtMethod& operator - () {
        return *this;
    }
    
    template<typename U>

kballenegger

//
// Fibonacci generator in C with Y-Combinator powered memoization.
//
// Written by Kenneth Ballenegger in 2013
//

#include <stdlib.h>
#include <stdio.h>
#include <Block.h>

bcardarella

module ActiveSupport::Concern
  def append_features(base)
    if base.instance_variable_defined?("@_dependencies")
      base.instance_variable_get("@_dependencies") << { :module => self, :method => :include }
      return false
    else
      return false if base < self
      @_dependencies.each { |dep| base.send(dep[:method], dep[:module]) }
      super
      base.extend const_get("ClassMethods") if const_defined?("ClassMethods")

puffnfresh

module reornament

-- Idris translation of Agda code:
-- https://gist.github.com/gallais/e507832abc6c91ac7cb9

-- Which follows Conor McBride's Ornaments paper:
-- https://personal.cis.strath.ac.uk/conor.mcbride/pub/OAAO/Ornament.pdf

ListAlg : Type -> Type -> Type
ListAlg A B = (B, A -> B -> B)

chpatrick

{-# LANGUAGE QuasiQuotes, TemplateHaskell, ScopedTypeVariables #-}

module BakedVector where

import qualified Data.ByteString.Lazy as BSL
import Data.ByteString.Lazy (unpack)
import Data.ByteString.Builder (toLazyByteString)
import Data.ByteString.Builder.Prim
import Foreign.Storable
import qualified Data.Vector.Storable as VS

fasiha

In writing one’s own Base64 codec for the Cryptopals Crypto Challenge in Rust, one gets to a point where every chunk of four adjacent elements in an input vector has to be transformed into a chunk of three elements in an output vector.

That is, the string SSdt containing four ASCII bytes becomes the string I'm containing three ASCII bytes, and IGtp becomes  ki, and so on, so that SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t is decoded to I'm killing your brain like a poisonous mushroom.

I had a function to do this four-to-three downconversion but looping over the two arrays, lining up the indexes, the keeping track of magic threes and magic fours in my code gave me a headache as I worked through writing the following:

pub fn decode(s: &[u8]) -> Vec<u8> {
    let mut out: Vec<u8> = vec![0; s.len() / 4 * 3];
    for i in 0..ou

ndmitchell

{-# LANGUAGE StaticPointers #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances #-}

import Data.Binary
import System.IO.Unsafe
import GHC.StaticPtr

reiver-dev

import os
import sys
import argparse
from glob import glob
from itertools import chain

import fontforge

ADDITIONAL_LIGATURES = [
    'x.multiply',

Qqwy

/*
 * Date: 2018-11-26
 * Author of this C code: Wiebe-Marten Wijnja (Qqwy).
 * Author of original JavaScript-version: Unknown.
 *
 * This version uses phase-accumulation to ensure that the signal remains continuous throughout,
 * and that there are no nasty clicks when we change to the next note.
 * You can add the directive `DISCONTINUOUS VERSION` (using e.g. the `-D` flag of `gcc` and `clang`)
 * to compile it as the original version, that bases its samples only directly on the current sample,
 * and therefore includes clicks whenever the note changes.

Qqwy

#include <iostream>
#include <vector>

auto continuation = [](auto && val){return [=](auto && cont) { return cont(val);};};
auto style = [](const auto &val) { return val; };
auto mod = [](auto &&modv) { return [=](auto &&truecont){ return [=](auto &&falsecont) { return [=](auto &&val) { if (val % modv) { return truecont(val); } else { return falsecont(val); }; }; }; }; };
auto passing = [](auto &&val) { return [=](auto &&cont){ return [=](auto &&) {return cont(val);};};};

bool isLeapYear(int year){
  return (continuation)