August 2016 1HaskellADay 1Liners

• August 20th, 2016: maybeify :: (a, Maybe b) -> Maybe (a, b)
  Define maybeify. Snaps for elegance.
• Hardy Jones @st58 sequence
• Bruno @Brun0Cad mapM id
• Thomas D @tthomasdd {-# LANGUAGE TupleSections #-}
  mabeify (x,mY) = maybe Nothing (return . (x,)) mY
• Андреев Кирилл @nonaem00 import "category-extras" Control.Functor.Strong
  maybeify = uncurry strength
• bazzargh @bazzargh I can't beat 'sequence', but: uncurry (fmap.(,))
• Nick @crazy_fizruk distribute (from Data.Distributive)

August 2016 1HaskellADay Problems and Solutions

August 2016

• August 31st, 2016: Today's #haskell problem we prepare Merkle trees (used by #blockchain/#Bitcoin) by hashing data, then hashing hashes. Wow! That was a lot of hash...ing! SHA256 #crypto #Bitcoin #blockchain used for today's #haskell solution  
• August 30th, 2016: In today's #haskell exercise we look at #bitcoin mining machines comparing cost, efficiency and potential BTC found. Today's #haskell solution compares #bitcoin mining hardware ... by deriving a theorem of logic. Yeah. So: that. 
• August 29th, 2016: For today's #haskell problem we find the next number in a series. Then @JMVarnerBooks asks for an efficient encoding. A little bit of group, a little bit of compress, and we have today's #haskell solution. YES!
  
• August 26th, 2016: Today's #haskell problem continues with currencies, looking at gold, then comparing #bitcoin
  
  Today's #haskell solution 
looks at gold then compares to #bitcoin and generalizes recursion 

  

August 25th, 2016: Today's #haskell exercise looks at historical prices of #bitcoin. 

Today's #haskell solution is worth $180k ... five years ago. I wonder what it will be worth 5 years hence? 

 

August 23rd, 2016: Enough diving into the node's data, let's look at the structure of the related nodes for today's #haskell problem. The structure of tweets and related data for today's #haskell solution 

August 22nd, 2016: Today's #haskell problem is parsing twitter hashtags and a bit of data fingerprinting/exploration of same. BOOM! Today's #haskell solution analyzes hashtags twitter-users ('tweeps') use

August 19th, 2016: For today's #haskell exercise we look at unique users in a set of twitter graph-JSON. Today's #haskell solution gives us a list of users, then their tweets, from twitter graph-JSON data 

August 18th, 2016: For today's #haskell problem we extract and reify URLs from twitter graph-JSON. Today's #haskell solution extract URLs from twitter data as easily as looking up the URLs in a JSON map.

August 17th, 2016: For today's #haskell problem we explore the relationships from and to tweets and their related data. Today's #haskell solution relates data to tweets extracted from graph-JSON 

August 16th, 2016: For today's #haskell exercise we begin converting nodes in a graph to more specific types (Tweets are up first). We create some JSON Value-extractors and with those find the tweets in graph JSON in today's #Haskell solution 

August 15th, 2016: Today's #haskell exercise looks at twitter data as labeled/typed nodes and relations in JSON  

Okay! For today's #haskell solution we discover our node and relation types in twitter data-as-graphs JSON! 

August 10th, 2016: Today's #Haskell problem we look at the big data-problem: getting a grasp of large indices of tweets in graph JSON. Today's #Haskell solution time-stamps and gives 'small-data' indices to tweets from graph JSON 

August 9th, 2016: For today's #haskell problem we extract the tweets from rows of graph data encoded in JSON. Today's #Haskell solution extracts the tweets from graph JSON and does some simple queries. 

August 8th, 2016: For today's #haskell problem we look at reading in the graph of a twitter-feed as JSON and just a bit of parsing. We leverage the Cypher library for today's #haskell solution to look at 100 rows of tweets encoded as JSON 

August 5th, 2016: Today's #Haskell problem we go for the Big Kahuna: solving a Kakuro puzzle! 

Okay, we have a #Haskell solution ... finally ... maybe. The solver took too long, so I solved it myself faster :/ 

August 4th, 2016: Today's #Haskell exercise looks at (simple) constraints of unknown values for a sum-solver. Today's #Haskell solution also uses QBits to solve constrained unknowns 

August 3rd, 2016: Today's #haskell problem provides the cheatsheet: "What are the unique 4-number sums to 27?" We round-trip the Set category for today's #haskell solution

August 2nd, 2016: Today's #haskell exercise looks at solving our sums when we know some of the numbers already. QBits actually work nicely for today's #Haskell solution 

August 1st, 2016: For today's #Haskell exercise we play the 'Numbers Game.' The #haskell solution is a guarded combine >>= permute in the [Int]-domain. I like the Kleisli category; ICYMI.

1Liners for July 2016

• July 14th, 2016: So you have x :: [a] in the IO monad, and the function f :: a -> b What is the expression that gets you IO [b]?

July 2016 1HaskellADay Problems and Solutions

July 2016

• July 28th, 2016: Lao Tzu says what is crooked cannot be made straight... but what does that guy know? Today's #haskell exercise
• July 27th, 2016: For today's #haskell exercise we look at the shortest distance between any two points in a graph. Today's #haskell solution uses brute-force to find shortest distance paths, which works for small graphs 
• July 26th, 2016: Today's #haskell exercise looks at (one aspect of) shortest pathing through graphs. Today's #haskell solution is the shortest path through a graph, NOT using continuations. *WHEW* 
• July 25th, 2016: For today's #haskell problem we look at pathing through graphs with cycles. We avoid 'teh Sadeness' with today's #haskell solution of pathing graphs with cycles 
• July 22nd, 2016: For today's #haskell exercise we tear apart #graph-construction or -pathing ... or both. Today's #haskell solution works PERFECTLY if your graph doesn't have cycles like this one! 
  
• July 21st, 2016: Today's #haskell problem looks at simplifying the representation of pathing through #graph data The #haskell solution paths through a graph, but ... hm: not perfectly. We'll look at complete pathing today.
• July 20th, 2016: Yesterday, I didn't give complete information for the figure. Today's #haskell exercise rectifies that #graph Today's #haskell solution is a #graph of complete information of the figure, and a partial look into pathing 
• July 19th, 2016: For today's #haskell exercise we count crows. I mean triangles ... I mean (properly) trigons 
  
• July 15th, 2016: I posted this problem on github this morning but did not announce:  #Haskell exercise: extract date from twitter JSON So, BANG! right on the heels of the exercise announcement: Data.Aeson and a little Day-parsing for the solution.
• July 14th, 2016: Today's #haskell exercise ... get this! ... helps you find Haskell exercises, both problems and solutions! #graph For today's #haskell solution I went the graph DaaS-route to extract @1HaskellADay problems and solutions 
• July 12th, 2016: Today's #haskell excercise compiles the RID into a Haskell module and analyzes Pride and Prejudice 
• July 11th, 2016: Today's #haskell exercise decodes the RID/Regressive Imagery Dictionary from JSON
• July 8th, 2016: Today's #haskell exercise brings together replacing one set of symbols with another and qualified names in XML  The #haskell solution today WEARYs me, but it, surprisingly, has COFFEE, so I'm good! Encoding strings-as-symbols.  
• July 7th, 2016: Today's #Haskell problem is to write Bram Stoker's Dracula as Jane Austen would have ... erhm, sort of. Not literature: a rehash of Bram Stoker's Dracula using Jane Austen's words .. but then: have you read the original? 
• July 6th, 2016: So, loading up an encoding table is on the plate for today's #haskell exercise. We encode Pride and Prejudice as symbols then save it as a #haskell module 
• July 5th, 2016: We look at encoding names and qualified names for today's #haskell exercise. For today's #haskell solution we encoded (qualified) names as symbols using SymbolTable 
• July 4th, 2016: (summary) Report generation is the name of the game for today's #haskell exercise. And so in today's #haskell solution we generate a report! BOOP! 
• July 1st, 2016: *WHEW* It took two days to marshall the data set for today's #haskell exercise: convert junit test result-XML to CSV And the #haskell solution involves TagSoup parsing at applicative functors 

1HaskellADay 1Liners June 2016

• June 13th, 2016:
  You want this list: [1, -1, 1, -1, ...]
  How would you produce this value in #Haskell ?
  • Wai Lee Chin Feman @wchinfeman
    https://gist.github.com/skatenerd/08d70c45499e1610206a
    (set plop to be identity, and set transformstate to be (*) -1)
  • Philipp Maier @AkiiZedd `iterate negate 1’
  • Patrick Mylund @pmylund concat $ repeat [1, (-1)]
    • Gary Fixler @gfixler No need for the parens in a list.
  • Jeff Foster @fffej and Kevin Meredith @Gentmen
    iterate (* (- 1)) 1
  • Spencer Janssen @spencerjanssen and Андреев Кирилл @nonaem00
    cycle [1, -1]
    • Philipp Maier @AkiiZedd:
      I’m curious: Since concat is O(n) wouldn’t it take more and more time depending on how many items you take?
    • Patrick Mylund @pmylund Looks like they compile to the same thing https://gist.github.com/patrickmn/9a92ab2a088018b2c0631f3bcfd60ebe
    • Philipp Maier @AkiiZedd I’m actually surprised the compiler can optimise this away :o Thanks for showing me ddump-simpl!
    • Eyal Lotem @EyalL concat is foldr (++), not foldl. O(1) work is done to produce the next item. [1,-1]++([1,-1]++(...
• David Turner @DaveCTurner I'd actually write 'cycle [1,-1]' but I like the elegant, alliterative obscurity of   'iterate negate 1'
• Fatih Karakurt @karakfa alt=1:[-x|x<-alt]

June 2016 1HaskellADay Problems and Solutions

• June 29th, 2016: Today's #Haskell exercise is REALLY HARD! ... for Big Gov't. Can you solve it? A little bit of (well-typed) Prolog-like code gets us our #haskell solution for today 
• June 28th, 2016: For today's #haskell problem we do ... NOTHING! But we are introduced to coding software for a huge bureaucracy  ... AAAAANNNDDD three System imports and we've got today's #haskell solution. Groovy! 
• June 24th, 2016: #haskell problem today charts Stochastic Oscillators of a security  and includes a 'malus' problem: report generation 
  
• June 23rd, 2016: Today we look at using #haskell to chart moving averages of a stock's prices https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D23/Exercise.hs https://twitter.com/logicalgraphs/status/743409829843243008 
  
• June 21th, 2016: I pushed today's #haskell problem last night on git but did I announce it? sigh Complex roots of quadratic equations https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D21/Exercise.hs The #haskell solution gives us the Complex roots to any (Real) quadratic equation https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D21/Solution.hs
• June 20th, 2016: Solving quadratic equations is on the plate for today's #haskell exercise https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D20/Exercise.hs 
  
  It's not every day I code
  [formula] <*> [(-),(+)] <*> [q]
  Thank you, #haskell, for today's solution to do so
  https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D20/Solution.hs
• June 17th, 2016: My, my! Where has the day flown? Today's #haskell problem is to reinvent charting API! ... or not. https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D17/Exercise.hs
• June 16th, 2016: Today's #haskell exercise looks at representing $TWTR data as candlesticks https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D16/Exercise.hs 
  
• June 15th, 2016: For today's #haskell problem, we round out the Data.Matrix module with the definition of the identity matrix https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D15/Exercise.hs There are many ways to define the identity matrix. Today's #haskell solution does so with Cellular Automata Rule 16 https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D15/Solution.hs
• June 14th, 2016: Yesterday we computed the matrix determinant, today we'll invert a matrix and use it to solve systems of equations https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D14/Exercise.hs Today's #haskell solution inverts a matrix BECAUSE WE FEEL LIKE IT! Yeah https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D14/Solution.hs
• June 13th, 2016: For today's #haskell problem we *ahem* DETERMINE (eventually) to solve systems of equations https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D13/Exercise.hs The determinant is the sum of the products of the first row with the sub-matrix determinants, right? RIGHT! https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D13/Solution.hs
• June 10th, 2016: Today's #haskell problem looks at box-and-whiskers charting of data https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D10/Exercise.hs Boxes for realz, yo: https://en.wikipedia.org/wiki/Box_plot The #haskell solution has @geophf writing 'uncurry uncurry' and sincerely meaning it! 😱 https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D10/Solution.hs and box: 
  
• June 9th, 2016: Triangles are on my mind for today's #haskell problem: https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D09/Exercise.hs … bisecting them, then trisecting them.
• June 8th, 2016: For today's #haskell problem, just what you've always wanted: MATH HOMEWORK! We find the intersection of two lines https://github.com/geophf/1HaskellADay/blob/master/exercises/HAD/Y2016/M06/D08/Exercise.hs
• ANNOUNCEMENT: lpaste.net is acting up; cloning original @1HaskellADay github repository and putting the exercise there. FYI
• June 6th, 2016: Today's #haskell problem explores superstring theory http://lpaste.net/6891096377267322880 No, it doesn't, but saying that has a certain ring to it!
• June 3rd, 2016: We saw a solution to perfect matching yesterday. For today's #haskell problem, let's efficient-ize it! http://lpaste.net/1128504074363207680
• June 1st, 2016: Today's #haskell problem is pretty much counting complements ... pretty much. http://lpaste.net/9130195410017583104 These apparently simple problems are actually rather hard. Today we have a #P-complete #haskell solution http://lpaste.net/670419007353913344

May 2016 1Liners

One-liners

• May 24th, 2016:
  Given f :: a -> [a] -> b, g :: a -> c
  Write h :: c -> [c] -> b, point-free, in terms of f and g
  where h x y = f (g x) (map g y)
• May 16th, 2016: The next 3 #1Liner are of a piece, using
  data CmpV a =
   Vec { len :: Int, top :: a,  elts :: [a],
         cmp :: CmpV a -> CmpV a -> Ordering }
• Give the point-free definition of:
  twoVs :: CmpV a -> CmpV b -> ([a], [b])
• instance Ord (CmpV a) where
   compare v1 = uncurry (cmp v1) .  (v1,)
  Make compare point-free by removing v1 from above definition
• An Ord-instance needs an Eq-instance:
  instance Eq a => Eq (CmpV a) where
   v1 == v2 = elts v1 == elts v2
  point-free-itize (==)
• May 16th, 2016: You have the following lambda:
  \x y -> x == y || fn x y
  where fn :: a -> a -> Bool
  Point-free-itize
• obadz @obadzz without any fancy uses of the (a ->) Applicative :)
  curry $ foldr (||) False . flip map [(==), fn] . flip uncurry
• obadz @obadzz with fancy use of (a ->) Applicative :)
  curry $ liftA2 (||) (uncurry (==)) (uncurry fn)
• Noah Luck Easterly @walkstherain
  curry $ uncurry (||) . (uncurry (==) &&& uncurry fn)
• May 5th, 2016:
  sames :: Eq a => [a] -> [a] -> Int
  Counts equal values at the same indices in two lists.
  What is the point-free definition?
  
  • joomy @cattheory
    sames = curry (length . filter (uncurry (==)) . uncurry zip)
  • bazzargh @bazzargh and then Fatih Karakurt @karakfa
    ((length . filter id) .) . zipWith (==)
  • me: sum <<- fromenum="" li="" nbsp="" zipwith="">
  • Noah Luck Easterly @walkstherain
    sames = ((sum . map fromEnum) .) . zipWith (==)
  • `getSum . foldMap (Sum . fromEnum)` seems better than `foldr (bool id succ) 0` but both satisfy `[Bool] -> Int`
  • Андреев Кирилл @nonaem00
    let it = (length .) . (filter id .)  . zipWith (==)