ConnorBaker

module Main where

// Generates a 2d list of zero-indexed indices of an nxn matrix.
twoDimIndices : {n} (fin n, 1 <= n) => [n][n](Integer, Integer)
twoDimIndices = [ [ (a,b) | a <- [0 .. n-1] ] | b <- [0 .. n-1] ]

// Transforms an n-bit array into a 2d nxn-bit array.
// The (i,j)-th element of the 2d nxn-bit array is the value of the i-th and
// j-th bits of the n-bit array XOR'd together.
gen : {n} (fin n, 2 <= n) => [n] -> [n * n]

ConnorBaker

module Main where

import Data.Bits

nonDiagIndices :: Int -> [(Int, Int)]
nonDiagIndices n = [(a,b) | a <- [0 .. n-1], b <- [0..n-1], a /= b]

gen :: [Bool] -> [Bool]
gen ss = ws
  where

ConnorBaker

{-# LANGUAGE RecordWildCards #-}
module Main where

data Set = Set { first :: Int
               , second :: Int
               , third :: Int
               } deriving (Eq, Show)

data Permutation = Permutation { mapping :: Set -> Set
                               , name :: String }

ConnorBaker

Suppose that you have a list of transformations you want to apply to some starting value, like a pipeline.

Ideally, we could define something in the shape of a list:

transformers :: Pipeline
transformers = [ f0 :: a0 -> a1
               , f1 :: a1 -> a2
               , f2 :: a2 -> a3
 , ...

ConnorBaker

Setup the minimum working example:

stack new mwe simple --resolver lts

Add the data Test to src/main.hs:

module Main where

ConnorBaker

module Main where

import           Control.Arrow

data Polygon = Polygon { xCoords :: [Double], yCoords :: [Double], desiredArea :: Double } deriving (Eq, Show)

-- Some of the inputs aren't valid Haskell floating point numbers (they don't
-- have a leading zero) so we fix that.
sanitize :: String -> String
sanitize s@('.' : ss) = '0' : s

ConnorBaker

ffmpeg -i in.mp4 -c:v libx265 -preset placebo -x265-params "--rc-lookahead=250" -crf 36 -tune animation -c:a libopus -b:a 32k -vbr on -frame_duration 60 -application voip -strict experimental out.mkv

ConnorBaker

use std::io::{self, BufRead};

fn main() {
    // Get the input as an iterator
    // Transforms each line of input, a string containing a sequence of numbers
    // (indexed from one) into a vector of i64, all indexed from zero
    let stdin = io::stdin();
    let is =
        stdin
        .lock()

ConnorBaker

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

public class Main {

ConnorBaker

module Main where

import           Prelude
import           Control.Arrow
import           Data.List.Split                ( chunksOf )
import           Data.Maybe                     ( fromJust )
import qualified Data.ByteString.Lazy.Char8    as C
import qualified Data.Vector.Unboxed           as V

-- Zero index