For @BillLaboon hey @franklinchen is there an easy way in Haskell to find out which element in a list is most common, e.g. [1,1,1,2,3] -> 1 ?

Knuth/McIlroy word count task using Haskell

This example demonstrates a word-frequency analysis task using Haskell, showing how to compute and display the most common words from standard input. It chains data transformations through a pipeline: converting text to lowercase, replacing non-letter characters with newlines, splitting into words, and tallying counts with a hash map. The code relies on `Data.HashMap.Strict` for efficient key-value aggregation via `HashMap.fromListWith`, and uses `Data.List` for sorting and taking the top *n* results. The final output lists each word with its count, sorted in descending order of frequency. The example highlights functional composition and lazy evaluation in a concise, read-backwards data-flow style.

58% match

Gist 0e59d1c2d63aaea35573

This example demonstrates benchmark-driven optimization of recursion schemes in Haskell, using the Criterion library’s `defaultMain`, `bgroup`, and `bench` functions to measure performance. The code defines catamorphisms (`ffold`), anamorphisms (`funfold`), hylomorphisms, and build functions (`fbuild`, `funbuild`), then applies them to natural numbers, lists, and trees. It highlights how `INLINE` pragmas and `RULES` for fusion (e.g., `ffold/fbuild`) improve execution speed, as shown in benchmarks like `lengthL`, `mapL`, and `depthT` over sample data structures.

48% match

PowerQuery list functions cheat sheet

This example is a cheat sheet for Power Query's list functions, organized as a reference card with sections for addition, averages, generators, information, membership, numerics, ordering, and selection. It shows concise code snippets with sample outputs, such as List.Sum({1, 2, 3}) ⇒ 6 and List.Generate(() => 10, each _ > 0, each _ - 1) ⇒ {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}. The source is a gist by Hugoberry.

HHugoberry

45% match

Example from Programming4Humanists

This example visualizes word frequency in a text by processing the poem’s lines and filtering out common stopwords. It shows a ranked list of words by their occurrence count, displayed in descending order. The code uses XQuery 3.0 with functions like `fn:tokenize`, `fn:distinct-values`, and `fn:count` to compute frequencies, while reading the source text and stopword list from gist URLs. The rendering approach is a simple textual output of word elements, each carrying a `frequency` attribute, rather than a graphical chart.

CCliffordAnderson

I like this example of grabbing elements from a List until you reach your desired sum.

This example demonstrates a functional approach to accumulating values from a numeric sequence, stopping once the running total exceeds 100. The code constructs a range of integers from 1 to 10,000 using Scala’s `1 to 10000` collection, then applies `takeWhile` with a closure that mutates an external `var sum`. The predicate adds each element to `sum` and tests the condition `sum <= 100`, effectively yielding the shortest prefix whose cumulative sum is just under the target. The visualization likely shows the resulting list and the final sum, highlighting how `takeWhile` short-circuits iteration without materializing the full sequence.

BBBischof

Quicksort in XQuery

This visualization compares four XQuery implementations of the quicksort algorithm, each derived from a Haskell reference, to demonstrate functional programming in a query language. It shows how the same recursive sorting logic can be expressed with different XQuery 3.1 features, including `fn:head()`, `fn:tail()`, `position()`, and a random-number generator for permutation. The code uses `local:qsort` functions with `xs:integer*` sequences, and the final example applies the sort to a shuffled list of 1 to 100 generated via `fn:random-number-generator('permute')`. The display highlights syntactical variations, such as explicit `where` clauses versus nested `if` expressions, without altering the core algorithm.

CCliffordAnderson

Example of point-free style

This example demonstrates how to compose functions in a point-free style using Haskell’s `Control.Category` operator `(>>>)`. The code defines a `matches` function that checks whether a given string equals an `Option`’s name prefixed with `"--"`, without explicitly mentioning the arguments. It shows the data flow by chaining `name`, `("--" ++)`, and `(==)` together, making the logic declarative. The example uses a custom `Option` data type and a sample `helpOption` to test the matching with `"--help"`. The source is a gist by FranklinChen, illustrating readable point-free composition in a functional programming context.

Spark line

This example renders a stream of numbers as a row of sparkline glyphs, using Unicode block characters whose vertical position encodes each value relative to the dataset’s minimum and maximum. Written in Haskell, it processes input from standard input or command-line arguments via `System.Environment.getArgs` and `Data.ByteString.Char8`. The `buildInOnePass` function uses a lazy circular fold over the list to compute min/max and generate UTF-8 bytes for the eight possible block levels, requiring only a single pass over the data.