Chris A. bitemyapp

Electric indentation for parentheses, brackets, braces, commas, semicolons...

This isn't an issue of what I want, but rather when I want it. haskell-mode knows how to indent these things correctly, but I had to turn off electric indentation in haskell-mode because it does stupid things the rest of the time.

Concretely, I want a haskell-mode that knows how to be electric when there's only one "right" choice and that doesn't do stupid things when there are multiple possibilities.

Connecting to Redis from Yesod

This is a quick run-through of how I connected to Redis from a Yesod site (which used the default scaffolding). There isn't much specific to Redis here, so this information should apply to connecting to any database or service from Yesod.

Background: Basics of Hedis

First, a brief intro of the basics of Hedis:

{-# LANGUAGE OverloadedStrings #-}

Profiling performance

Using perf:

$ perf record -g binary
$ perf script | stackcollapse-perf.pl | rust-unmangle | flamegraph.pl > flame.svg

NOTE: See @GabrielMajeri's comments below about the -g option.

Intro

I've been working on a parser for a Haskell-like syntax called Duet. In the implementation I've taken particular care to make an awesome tokenizer and parser that is super helpful to learners.

Jasper Van der Jeugt made a talk about producing good error messages recently, which coincides nicely with my parallel work on this. So I thought I'd also share my

Where you able to produce a binary directly from the Rust build tools that you could submit to the app/play store?

Not quite, but I tried to get as close to that as was reasonably possible. Alas, things ended up a little convoluted.

For iOS, I have a nearly empty Xcode project with a build script that copies my cargo produced executable into the .app that Xcode generates (before Xcode signs it). The build script also uses lipo to merge the executables for each architecture I’m targeting (e.g. armv7 and aarch64 for non-simulator devices) into a single, universal binary.

On top of that, there are various iOS-y things that need to happen before my application’s main method is called. SDL2 provides the Objective-C code that does all of that. In a C or C++ game, SDL2 renames main to SDL_main, and then [inserts its own mai

	{-# language KindSignatures #-}
	{-# language PolyKinds #-}
	{-# language DataKinds #-}
	{-# language TypeFamilies #-}
	{-# language RankNTypes #-}
	{-# language NoImplicitPrelude #-}
	{-# language FlexibleContexts #-}
	{-# language MultiParamTypeClasses #-}
	{-# language GADTs #-}
	{-# language ConstraintKinds #-}

	-- run it like:
	-- stack ghc --package criterion -- binary.hs -Wall -O2 && ./binary
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE BangPatterns #-}
	module Main where

	import Data.ByteString.Lazy (ByteString)
	import Data.Binary
	import Data.Fixed

	{-# LANGUAGE DeriveFunctor #-}
	{-# LANGUAGE LambdaCase #-}

	import Control.Applicative.Free
	import Control.Monad
	import Control.Monad.Free
	import Control.Monad.Primitive
	import System.Random.MWC.Probability (Prob)
	import qualified System.Random.MWC.Probability as MWC

	-- This is a valid PID 1 process in Haskell, intended as a Docker
	-- entrypoint. It will handle reaping orphans and handling TERM and
	-- INT signals. This is a work in progress, please do not use it in
	-- production!

	{-# OPTIONS_GHC -Wall -Werror #-}
	import Control.Concurrent (forkIO, newEmptyMVar, takeMVar, threadDelay,
	tryPutMVar)
	import Control.Exception (assert, catch, throwIO)
	import Control.Monad (forever, void)

	apiVersion: extensions/v1beta1
	kind: Deployment
	metadata:
	name: all-cabal-tool
	labels:
	app: all-cabal-tool
	spec:
	replicas: 1
	minReadySeconds: 5
	template: