Skip to content

Instantly share code, notes, and snippets.

Matt Parsons parsonsmatt

Block or report user

Report or block parsonsmatt

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
parsonsmatt / gist:f64393b9349592b6f1c1
Last active May 13, 2017
class composition in ruby
View gist:f64393b9349592b6f1c1
# In Haskell, you write a function like this:
# f :: a -> b
# which reads as "f is a function from type a to b"
# Function composition allows you to chain functions together,
# building more powerful and complex composite functions from
# simpler component functions.
# OOP does not have a similar mechanism. Composition in OOP seems
# to mostly be limited to aggregation and delegation, neither of
parsonsmatt / class_currying.rb
Last active Aug 29, 2015
ruby class currying
View class_currying.rb
# gem install 'beethoven'
require 'beethoven'
# Beethoven enables class composition. Unfortunately, the mechanism
# seems to be somewhat limited: each class only takes a single argument
# in the `new` method.
# While composing classes in this manner can be powerful, the true
# power is lost without the ability to "curry" this class composition.
View gist:12cb2e444dd2024d9836
module Auth where
main :: IO ()
main = putStrLn $ unlines $
[ "pretend website"
, "Logged in as regular user, trying to see my profile"
, if authorize regUser Read regUser
then profile regUser
else "forbidden"
, "Logged in as admin, trying to delete post"
View multi_send.rb
class Object
def send_array(*messages)
messages.reduce(self) { |obj, message| obj.send(*message) }
def send_hash(**messages)
send_array( { |k, v| [k, *v] })
def multi_send(*messages)
parsonsmatt / curry.rb
Created Jul 23, 2015
when currying is useful
View curry.rb
# Currying: What, How, Why
# Currying is a way to change the arity of functions.
add = -> x, y { x + y }
# Any function that takes multiple arguments can be expressed as a function
# that takes a single argument, and returns a function taking a single
# argument, etc. until eventually all arguments are given and a value is
# returned.
add = -> x { -> y { x + y } }
View which_bar.rb
WhichBar =
attribute: :open,
value: true
attribute: :people,
aggregator: {
klass: :compare,
View lol.hs
allDifferent :: Ord d => [ID] -> Constraints d
allDifferent ids = do
domains <- forM ids (use . domainAt)
let unified = mconcat domains
newDomains = map (\d -> d \\ (unified \\ d)) domains
zipWithM_ updateVariable ids newDomains
parsonsmatt / freeeeee.hs
Last active Nov 11, 2015
to free or not to free
View freeeeee.hs
-- so I can either have a convention on returning a bare bool value
-- out of this strangeness.
data AndF k = forall f. (AndF :<: f) => And (Free f Bool) (Free f Bool) (Bool -> k)
testProgram :: (AndF :<: f) => Free f Bool
testProgram = do
asdf <- true .&& false
hmmm <- false .&& true
wat <- pure asdf .&& pure hmmm
View dpll.hs
DPLL from the textbook:
function DPLL(clauses, symbols, model ) returns true or false
if every clause in clauses is true in model then return true
if some clause in clauses is false in model then return false
P , value ← FIND-PURE-SYMBOL (symbols, clauses, model )
if P is non-null then return DPLL(clauses, symbols – P , model ∪ {P =value})
P, value ← FIND-UNIT-CLAUSE (clauses, model)
if P is non-null then return DPLL(clauses, symbols – P , model ∪ {P =value})
View rose.hs
module Rose where
import Data.List (findIndex)
data Tree a = Node { value :: a, getSubForest :: [Tree a] } deriving Show
insertPath :: (Eq a ) => [a] -> Tree a -> Tree a
insertPath [] tree = tree
insertPath (x:xs) (Tree a subForest) = Tree a modifiedSubForest
You can’t perform that action at this time.