February 2018 1HaskellADay problems and solutions

• February 28th, 2018: Wednesday's #haskell problem: (sung:) Ya know that I love Casey's Mom! (guitar wails) Wednesday's #haskell solution we solve with LOGIC PROGRAMMING! ... IN HASKELL! YES! 
• February 27th, 2018: Tuesday's #haskell problem: A job scheduling problem, posed by Mensa, answered by Haskell. Tuesday's #haskell solution is this lcm/scan-like function, because "... the work is never done." 
• February 22nd, 2018: Thursday's #haskell problem is counting in Haskell IN YOUR NATIVE LANGUAGE! 
• February 21st, 2018: Wednesday's #haskell problem is sorting lists and making list-o-lists from lists, via P99 and random.org because my love-affair with #Prolog. *ahem* (pure) Prolog. Wednesday's #haskell solution: lsort and lfsort, provided to you by sortOn and by @bazzargh and @xgrommx 
• February 20th, 2018: Tuesday's #haskell problem: More fun with elements in a list! Whee! Tuesday's #haskell solution: the monad-y approach, with alternatives by @xgrommx @bazzargh @johannesweiss 
• February 19th, 2018: Monday's #haskell exercise is from @fermatslibrary: permutable primes. Monday's #haskell solution: Primes. Permutable. ... #PWND! 

• February 16th, 2018: For Friday's #haskell problem P99 Prolog problem 33, coprime numbers with an assist by random.org. Friday's #haskell solution is coprimes: as easy as you please! 
  
• February 15th, 2018: Thursday's #haskell problem is the greatest common denominator via P99 Prolog problem set. For today's #haskell solution I'VE JUST (re)INVENTED GCD! KNEEL BEFORE ZOD! 
• February 14th, 2018: For Wednesday's #haskell problem: "I'm thinking of a word that has the letter 'V' ..." Happy Valentine's Day ... as an anagram! Today's #haskell solution was defined with ALACRITY! YUS! 
• February 13th, 2018: Tuesday's #haskell problem: we have unicode, and we could parse that as Text, but why do that when they want plain, old ASCII? ... why, indeed! Removing non-ASCII characters from documents is one approach to parsing them... 
• February 12th, 2018: A little CSV to JSON work via #haskell today. Monday's #haskell solution: 🎵 You say CSV, I say JSON. Let's call the whole thing off! 🎵 
• February 9th, 2018: Logs get stale, quickly! Let's archive old log entries for Friday's #haskell problem... so quickly, in fact, that the Friday's #haskell solution archived 270k+ rows of log entries! 
• February 7th, 2018: So, we will update articles in our PostgreSQL data store, but what happens when your codec is LATIN1 and you need to store the article as UTF8? Wednesday's #haskell problem. Wednesday's #haskell solution: TFW the exercise is an update function, but the solution goes whole-hog! smh 🙄 
• February 6th, 2018: Tuesday's #haskell problem is timestamping packets and associating articles with the packets that downloaded them. Tuesday's #haskell solution: associating the articles we uploaded TODAY with the packet we uploaded TODAY! 
• February 5th, 2018: On #SuperBowlSunday I release Monday's #haskell problem which is to timestamp log entries, because that's what we live for. Today's #haskell solution was a stunning victory by the Philadelphia Eagles ... no, ... wait: it was log entries, timestamped. There. #nailedit 
  
  
  
  
• February 2nd, 2018: We've downloaded a the most recent set of articles from a REST endpoint; now we have to exclude Associated Press articles from our local paper's set. Friday's #haskell problem. Today's #haskell solution filters out Associated Press articles from out downloaded article-set. 
• February 1st, 2018: Thursday's #haskell problem is from a picture posted from @fermatslibrary: anagrams as prime-multiples. Teacher: Class the following words are all English words: "Elaps lapse Lepas Pales salep saple sepal slape spale speal" Class: ... <<- a="" haskell="" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgN14nLdE2N0f2Zonc4xiXS9QwTY6ZiCvibeBzWRFL3szla11GYssWss4Isip5EOAyig2nAGzc8T2JSUP2iEC3AJbfknerzXflXeO_Y9CSfweII2Wwb_PXNxSoAcBXMZvqhWB7FFREgKsYT/s1600/anagram-by-primes.jpg" imageanchor="1" no="" s="" solution.="" style="color: #7d181e; margin-left: 1em; margin-right: 1em; text-decoration: none;" words.="" yesterday="">

January 2018 1Liner 1HaskellADay problems and solutions

• January 8th, 2018: from Nicoλas‏ @BeRewt
  A small @1HaskellADay, old-school. Define foo:
  
  > foo 3 [1..5]
  [([1,2,3], 4), ([2,3,4], 5)]
  
  > foo 2 [1..4]
  [([1,2], 3), ([2,3], 4)]
  
  > foo 2 [1..20]
  [([1,2],3), ([2,3],4), ..., ([18,19],20)]
  
  > foo 20 [1..2]
  []
• Demiurge With a Teletype @mrkgrnao
  foo n
    = tails
    # filter (length # (> n))
    # map (splitAt n # second head)
  
  (#) = flip (.)
• Andreas Källberg @Anka213
  I haven't tested it, but this should work:
  foo n xs = [ (hd,x) | (hd , x:_) <- n="" splitat=""> tails xs ]
• <- n="" splitat="">Nicoλas @BeRewt foo n = zip <$> fmap (take n) . tails <*> drop n
• January 5th, 2018: You have the following DAG-paths:
  
  a -> b -> c -> e
  a -> b -> d -> e
  q -> r -> s
  w -> x
  y -> z
  
  and many more.
  
  From a path, provide a bi-directional encoding* given maximum graph depth is, say, 7, max number of roots is, say, 10, and max number of nodes is, say, 1000.
• *bi-directional encoding of a graph path:
  
  DAG path -> enc is unique for an unique DAG path
  enc -> DAG path yields the same DAG path that created the unique enc.
  
  *DAG: "Directed, acyclic graph."
• January 5th, 2018: given s :: Ord k => a -> (k,[v])
  
  define f using s
  
  f :: Ord k => [a] -> Map k [v]
  
  with no duplicate k in [a]
• Christian Bay @the_greenbourne f = foldr (\e acc -> uncurry M.insert (s e) acc) M.empty
• me: you can curry away the acc variable easily
• Christian Bay @the_greenbourne You're right :)
  f = foldr (uncurry M.insert . s) M.empty
• Bazzargh @bazzargh fromList.(map s) ?
• me: Yuppers

January 2018 1HaskellADay Problems and Solutions

• January 30th, 2018: For Tuesday's #haskell problem we look at triaging articles downloaded from a REST endpoint against our PostgreSQL database. Who knew putting things into three bins could be so much fun? Today's #haskell solution triages work for us. 
• January 29th, 2018: Monday's #haskell problem is to fetch when the last set of articles were stored; two approaches. Monday's #haskell solution: two approaches to extract 'last entry' from the database, wanted; two approaches to extract 'last entry' from the database, GOT! 
• January 26th, 2018: Friday's #haskell problem is to pull a week's worth of data from a REST endpoint when we don't know a priori how many calls we have to make. Friday's #haskell solution fetches then reads/parses blocks of articles from a REST endpoint. 
• January 24th, 2018: Wednesday's #haskell problem is solving three more #Prolog-y list problems from P99: pack / encode / decode. It's great when #haskell has grouping / 'un'grouping functions in the library already. 
• January 23rd, 2018: Tuesday's #haskell problem: groups and grouper ... I like grouper blackened, please! Solving today's #haskell problem with Qubits?!? Nah, not really, but that would be cool if we did! 
  
• January 22nd, 2018: Monday's #haskell problem is a problem from P99: problem P21, list insertion. Monday's #haskell solution is inserting an element into a list, PROLOG-STYLE! 
• January 18th, 2018: The whole enchilada! Today's #haskell problem ties it all together to make an ETL. Today's #haskell solution defines etl: Looping over calls to the REST endpoint then database insertions. 
• January 17th, 2018: For today's #haskell problem we use PostgreSQL data store and Haskell to pick up where we left off on an application run. Today's #haskell solution: the audit log has what our program last did, so now we know what we'll work on next! 
• January 16th, 2018: Where did yesterday's Haskell problem go? Here it is! Today's #haskell problem: read a packet from a REST endpoint. Today's #haskell solution accesses a REST endpoint with a set timeout and with the default timeout.
• January 15th, 2018: "Logging? Why do we have to log stuff?" Enterprise applications require audit trails. Today's #haskell problem provides one. What did your Haskell app do and when? Today's #haskell solution: an audit log. 
  
• January 11th, 2018: Thursday's #haskell problem: pulling SQL lookup tables into Haskell. Thursday's #haskell solution: with the help of IxValues we extract lookup table values from SQL into Haskell Maps. 
• January 10th, 2018: Wednesday's #haskell exercise is to store the packet information into the PostgreSQL database as a part of auditing the ETL process. Wednesday's #haskell solution stores the packets that wrap article sets then logs our results. 
  
• January 9th, 2018: Tuesday's #haskell problem we are logging log messages to the log data table. YES! Tuesday's #haskell solution: logging in the style of log4j. 
• January 8th, 2018: Monday's #haskell problem: once more into the breach, and thoughts on generalization – storing unique newspaper article sections in PostgreSQL. We store article section information, then we build a function that stores ANYTHING! ... and washes windows, TOO! *
  
  *YMMV additionaltermsandconditionsmayapplydependingonyourregion 
• January 5th, 2018: Friday's #haskell problem takes a break from SQL Databases and Haskell and does something completely different: data schemes and Haskell. AHA! Friday's #haskell solution is a graph-view of the sections for a sample of 100 articles. 
  
• January 4th, 2018: Thursday's #haskell problem looks at storing in PostgreSQL authors of periodic articles uniquely identified by uuid. Thursday #haskell solution uses etl function with generators to store parsed authors in PostgreSQL database. 
  
  
  
  
• January 3rd, 2018: Wednesday's #haskell problem is in honor of Baron Munchausen and his fantastic adventures! 
• 
• January 2nd, 2018: WELCOME TO THE NEW YEAR, HASKELLERS!
  
  Tuesday's #haskell problem leverages keywords-as-subjects and makes storing article keywords into PostgreSQL easier... we hope. Tuesday's #haskell solution Incorporates prior work with memoizing tables and subjects with results. 
  

December 2017 1HaskellADay 1Liners problems and solutions

• December 29th, 2017:
  given f :: Monad m => n -> a -> m (Maybe b)
  define g :: Monad m => n -> a -> m (a, Maybe b)
  using f and ... arrows? Kleisli category?
• Bazzargh @bazzargh (\n a->liftM ((,) a) (f n a)) ... according to pointfree.io, that's `liftM2 fmap (,) . f` but I can't pretend to get the transformation
• December 29th, 2017:
  given f :: a -> b
  define g :: [a] -> [Maybe c] -> [(b, c)]
  
  >>> g [1,2,3] [Just 7, Nothing, Just 10]
  [("1",7),("3",10)]
  
  when f = show
• matt @themattchan
  g = catMaybes ... zipWith (fmap . (,) . f)
  where (...) = (.).(.)
• garrison @GarrisonLJ g a b = map (f.id***fromJust) . filter (isJust . snd) $ zip a b
• TJ Takei @karoyakani g = (catMaybes .) . zipWith ((<$>) . (,) . f)
• December 29th, 2017: define f :: [(a,b)] -> ([a], [b])
• Андреев Кирилл @nonaem00 and matt @themattchan unzip
• Victoria C @ToriconPrime f = fmap fst &&& fmap snd
• (in a vacuum, a more general type signature would be inferred, but the compiler limits itself as instruct)

December 2017 1HaskellADay problems and solutions

• December 29th, 2017: In Friday's #haskell problem we leave 2017 with a filter and a BANG! ... BANG! Today's #haskell solution we weave logging into the ETL article upload process. 
  
• December 28th, 2017: Thursday's #haskell problem is late AND a quicky: fetch a row of JSON from the database and pretty-print it. Thursday's #haskell solution had me leap from the bath tub and shout EUREKA! as I saw the issue in the JSON. 
• December 27th, 2017: In Wednesday's #haskell problem we learn that when you parse dates for your articles, you don't need to carbon-date it anymore. In the solution to yesterday's #haskell problem, we encounter and report some parsing issues around optionality. 
• December 26th, 2017: Tuesday's #haskell problem: scan an article archive, store an article archive; databases are neat that way. Today's #haskell solution: storing articles-as-JSON into a PostgreSQL database? No problem! 
• December 22nd, 2017: Friday's #haskell exercise we do our first bit of parsing with the help of tagsoup. Okay, this #haskell Aeson / TagSoup stuff is awesome for parsing JSON / HTML stuff. 
• December 20th, 2017: Wednesday's #haskell exercise. We take a large-ish JSON article archive, scan it, and spit out* a smaller-...ish JSON article archive. *'spit out' is a technical term. Today's #haskell solution provides a subset of the JSON article archive printed prettily.
• December 18th, 2017: Monday's #haskell problem: Friday you submitted an oembed request for goats, today you create a JSON oembed response service. Today's #haskell solution brings you a goat oembed service, serve with PHP. 
  
• December 15th, 2017: Today we build a goat oembed request. I kid you not! geddit? GEDDIT? Today's #haskell solution: OEmbed Goats requests, want? OEmbed Goats requests, GOT!  

• December 14th, 2017: Thursday's #haskell problem we sing 🎵 ... EVERYBODY'S WORKIN' FOR THE WEEKEND! 🎶 So, 18 composeable dates on the weekends. I'm freeing up my calendar, then! 
• December 13th, 2017: Wednesday's #haskell problem is a hot date! WOOT! Today's #haskell solution has 66 composable dates in 2017. Cool! 
• December 12th, 2017: Tuesday's #haskell problem is batching a SQL queryinstead of making multiple queries. It is so much faster! Today's #haskell solution has another LEFT JOIN in the SQL query to consolidate data gathering. 
• December 11th, 2017: Monday's #haskell problem is computing and storing exponential distribution values. The exponential distribution: today's #haskell solution shows it's really simple. 
  
• December 8th, 2017: For Friday's #haskell problem we parse NYT article summaries and upload them to a PostgreSQL database. Today's #haskell solution shows that our simple parsing exercise wasn't so simple. Isn't dirty data delightful? 
• December 7th, 2017: Throwing the switch with Thursday's #haskell with a hard reset of the database. For today's #haskell solution we do a hard reset: we wipe the recommendation and publish tables and repopulate. 
• December 6th, 2017: It's 'kinda' bad to return articles from a search that are already recommended. Wednesday's #haskell problem fixes this. Today's #haskell solution shows what a simple filter notMember can do. 
• December 5th, 2017: Tuesday's #haskell problem we narrow our focus and structure our keyword search-space only on keys requested in the NYT archive on PostgreSQL. With a little bit of monadic/applicative magic, we have narrowed keyword searches. 
• December 4th, 2017: For Monday's #haskell problem: "But can Haskell do anything useful?" Two words: ... yes.
• December 1st, 2017: For Friday's #haskell problem, what happens when the boss says: "That's good, but ..."? REWORK! THAT's what happens! Today's #haskell solution renders the source article in full and the recommended articles in brief. Got it! 

November 2017 1HaskellADay 1Liner problem and solutions

• November 5th, 2017: f :: Map Int [a] -> [b] - > [(Int, b)]
  for, e.g.: f mapping bs
  length bs == length (concat (Map.elems mapping))
  define f
• Andreas Källberg @Anka213 Using parallel list comprehensions:
  f mp bs = [ (k,b) | (k,as) <-assocs mp, a <- as | b <- bs]
• Steve Trout @strout f = zip . foldMapWithKey (fmap . const)

November 2017 1HaskellADay problems and solutions

• November 30th, 2017: For Thursday's #haskell problem we've published our articles to the PostgreSQL database, now let's extract them as JSON. Today's #haskell solution is a simple SQL query and applying some work from previous exercise to fetch and JSONify recommended articles to print! 
• November 29th, 2017: For Wednesday's #haskell problem, now that we've selected the recommended articles, let's save that for review to the PostgreSQL database. For today's #haskell solution, we delete the old recommendations-to-be-published, we insert the new set. Voilà! 
• November 28th, 2017: Monday we added articles from a PostgreSQL database using #haskell; Tuesday we delete articles. WHEEEEE! Today's #haskell solution shows that deleting article recommendations is very much like adding recommendations, ... in reverse. WHODATHUNK! 
• November 27th, 2017: Monday's problem: "It's not rocket science!" Adding articles to a recommendation set in PostgreSQL with #haskell. A little bit of #haskell; a little bit of #PHP and we have an article-adder-webservice ... thingie! 
• November 24th, 2017: Friday's #haskell problem: PostgreSQL database, JSON, Haskell: you've got yourself a webservice. Friday's #haskell solution uses the Brief-structure, this time to show article recommendations.
• November 23rd, 2017: For Thursday, a fun little #haskell JSON-y exercise on Thanksgiving Day from the USA to you! Y'know, Nietzsche says: "Out of chaos comes JSON." ... no ... wait. 
• November 22nd, 2017: Wednesday's #haskell problem: given a NYT article index, extract the article full text from PostgreSQL. Simple, eh? ... 'maybe.' Full text of NYT articles archived in PostgreSQL as JSON. 
• November 21st, 2017: Tuesday's #haskell problem we slim down the article JSON returned from yesterday by providing article briefs. Today's #haskell solution goes from a set of recommendations from NYT articles to briefs. 
• November 20th, 2017: Monday's #haskell problem moves keyword/key-phrase-article retrieval and matching to the PostgreSQL database. Today's #haskell solution: we build our keyword-key-phrase dictionary from SQL and filter articles indexing from those keywords. 
• November 17th, 2017: Thursday we linked keywords to key-phrases; for Friday's #haskell problem, we'll upload that linkage information to a PostgreSQL data store. Today's #haskell solution stores 26,000+ keywords, with almost 240,000 cross-references into nearly 10,000 NYT articles. Whoa. 
• November 16th, 2017: Thursday's #haskell problem: provide a mapping from unique keywords to key-phrases containing them. Mapping keywords to key-phrases, it's what we do for today's #haskell solution. 
• November 15th, 2017: Wednesday's #haskell problem is to parse a CSV file of articles to upload to an article MongoDB. Today's #haskell solution has a little bit of CSVing and a little bit of JSONification to upload article information into MongoDB. 
• November 14th, 2017: Tuesday's #haskell exercise is a parsing exercise of a different sort: parsing CSV, but with embedded quote within columns! Ooh! We now can parse CSV files with embedded quotes. YES! Adding that to the old CSV parsing library. 
• November 13th, 2017: Indexing articles by keyword and then searching articles by keyword for Monday's #haskell problem. For today's #haskell solution we intersect sets of articles to do fast keyword searches. 
• November 10th, 2017: Friday's #haskell exercise is to load the keywords and recommended articles into the PostgreSQL database. Thanks to today's #haskell solution we have articles and keyphrases indexed by keyword. 
• November 9th, 2017: Thursday's #haskell problem ties NYT article data stored in PostgreSQL together with the recommended articles from JSON. Today's #haskell solution is reading NYT article recommendations from a PostgreSQL database. 
• November 8th, 2017: Wednesday's #haskell problem is to combine article recommendations with their key-phrases to output as JSON. Wednesday's #haskell solution: JSON: GET. (p.s. I love Data.Aeson.Encode.Pretty)
• November 7th, 2017: Tuesday's #haskell problem is to parse JSON of NYT articles and their metadata. Today's #haskell solution: we have articles stored as JSON, and, voilà! we materialize those articles! 
• November 6th, 2017: Monday's #haskell exercise is to parse a CSV file of recommended articles from the NYT archive. Today's #haskell solution uses the reads-function to guide the parsing of values from a CSV file.
• November 3rd, 2017: Today is Friday! YAY! Do you know what that means? It's PARSING DAY is #haskell-land! YAY! ... no ... wait. What? TIL that parsing keywords and parsing LISTS of keywords can be very different things for today's #haskell solution.
• November 2nd, 2017: Today's #haskell problem: 'Hello, world' in Haskell. Snark on the side FO' FREE! I don't recall Eliza being this snarky, but today's #haskell solution says differently. 
• November 1st, 2017: Wednesday #haskell problem is scan a new archive and update the special character file or correct the new archive. The #haskell solution to replacing special characters... WHAT special characters? They GONE! #ETL