Edward Kmett ekmett

Those, frankly, are a very poor subset of shuffles.
The shuffle* primops exposed by GHC (for example shuffleFloatX4#) take runtime vector arguments that specify shuffle indices dynamically.
They correspond to register-controlled SIMD shuffle operations on x86.
Unfortunately, those are not efficient variants — they’re just the ones that cleanly map onto our current primop representation, and they often don't even exist on older CPUs.

Let’s take a dive through Intel’s “shuffle-like” operations.
Of these, the first group uses compile-time immediates to select shuffle positions, and thus are the ones we’d want to reach eventually, if we knew the constants involved at all.

Instruction	Width	Control	Description

	{-# language DefaultSignatures #-}

	-- @Fib a b :: Fib r@ denotes @aΦ + b@ ∈ r(Φ)
	data Fib a = Fib !a !a
	deriving (Show, Functor, Foldable, Traversable, Eq)

	instance (Num a, Ord a) => Ord (Fib a) where
	compare (Fib a b) (Fib c d) = case compare a c of
	LT \| b <= d -> LT
	\| otherwise -> go compare (a-c) (b-d)

	<!DOCTYPE html>
	<html>
	<head>
	<title>SSN Ranges by State</title>
	<style>
	#map {
	height: 600px;
	width: 100%;
	}
	</style>

	Once upon a time,
	In the land of code,
	There lived a young programmer,
	Named Edward Kmett.

	He was skilled in many languages,
	And excelled in their use,
	But one day he stumbled upon,
	The mighty Haskell's muse.

	#![allow(non_camel_case_types)]

	// type-inferrable lenses for rust can exist

	// the bokeh of a lens is the stuff that is out of focus.
	// this trait describes how given the lens as context, and a bokeh
	// you can reassemble the result.

	pub trait Bokeh<C,B> {
	type T;

	#!/usr/bin/env cabal
	{- cabal:
	build-depends: base, constraints, ghc-prim
	-}
	{-# language AllowAmbiguousTypes, ConstrainedClassMethods, ConstraintKinds,
	DefaultSignatures, FlexibleInstances, ImplicitParams, RankNTypes,
	ScopedTypeVariables, TypeApplications, TypeFamilies, UndecidableSuperClasses #-}

	import Control.Applicative
	import Control.Concurrent.MVar

	{-# language BlockArguments, TupleSections #-}

	import Data.Array
	import Data.Foldable
	import Data.Char
	import Prelude as P

	type Pattern = Int

	-- each pattern is an equivalence class of words, basically a color pattern.

	You rolled out of bed and stretched your lazy bones and looked over at the clock. You're late to work.

	Ever since western civilization figured out that necromancy was an easy path to a cheap labor force that didn't need to be fed, life, or rather unlife, has been going downhill. Fortunately, summoning rituals are too expensive, so the world isn't literally going to hell, yet.

	You stumbled over to the bathroom shower, and shut the door. You don't have eyes any more, so there's no real point to turning on the lights. No real point to anything really. It's not like I have any other choice.

	"Hey Suzy…" you hear from the bathroom door. "Are you in there?"

	You groggily look around the room and look over at the door. There is no one in the bathroom.

	aahed
	aalii
	aargh
	aarti
	abaca
	abaci
	aback
	abacs
	abaft
	abaka

	aback
	abase
	abate
	abbey
	abbot
	abhor
	abide
	abled
	abode
	abort