Example of point-free style

100%

Example of point-free style

✓ Published0🌍 Public

Last edited Oct 6, 2014

Created on Oct 6, 2014

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist ec627b32670dd31f4028

This example demonstrates a modular approach to building and testing effectful programs using the free monad pattern in Scala. It defines a `Free` monad to sequence interactions like console prompts and authentication checks, with interpreters separating execution from logic. The code uses type classes `Monad`, natural transformations (`~>`), and coproducts to compose independent algebras (`Interact` and `Auth`). It shows both a production interpreter (`Console`) and a pure test interpreter (`TestConsole`) that returns output lists from a static input map, highlighting how to decouple I/O from program structure.

FFranklin Chen

58% match

Loading thumbnail…

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.

FFranklin Chen

54% match

Loading thumbnail…

"" + 0

This example humorously demonstrates Haskell’s typeclass overloading by defining a `Value` type that can behave like both a number and a string. It uses the `Num` and `IsString` instances to make the expression `"" + 0` compile and evaluate to the string `"0"`. The code relies on the `OverloadedStrings` language extension and the `Data.String` module, while the `Show` instance outputs the underlying representation. The gist illustrates how Haskell’s ad-hoc polymorphism can mimic loosely-typed language syntax.

FFranklin Chen

52% match

Loading thumbnail…

Clojure thoughts and tips

The example shows a Clojure gist that clarifies the distinct behaviors of the standard functions `comp` and `juxt` through commented code and live map calls. It first demonstrates `juxt` with `map`, `name`, and `str/capitalize` to produce pairs like `["name" ":name"]`, then examines `comp` to reveal its right-to-left application order, correcting an initial misuse. The code uses Clojure core APIs such as `clojure.core/comp`, `clojure.core/juxt`, `map`, and `str/capitalize` directly in the REPL. The source is a gist authored by Eleonore9, with rendering limited to text output from the function calls.

EEleonore9

52% match

Loading thumbnail…

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.

FFranklin Chen

52% match

Loading thumbnail…

Gist 7d6a7404e99051bb7d2f36c61f0113ae

This example demonstrates functional programming techniques in JavaScript, including currying, composition, and generator functions. It shows how currying enables partial application, as seen with the `sum` function and reusable helpers like `getName` and `mapUserNames`. The code uses `compose` with `reduceRight` to chain array transformations, filtering user names by length. It also illustrates generator behavior with `next(true)` to control iteration completion. The data is a hardcoded array of user objects, and output is logged to the console via `console.log`.

IIliaIdakiev

51% match

Loading thumbnail…

Pipe forward operator and curried free functions = fluent interface

This Swift example demonstrates how the pipe-forward operator (`|>`) and curried free functions restore a fluent interface for string manipulation. The code contrasts an initial `Stringy` struct with method chaining, a nested free-function alternative, and finally a curried `appendCurriedFreeFunction` composed with `|>`. The final pipeline chains `greeting` through three append operations and `printMe`, showing functional composition that mirrors the original object-oriented style without modifying the struct.

CColinEberhardt

50% match

Loading thumbnail…

Clojure thoughts and tips

This example illustrates Clojure’s multimethod polymorphism by defining a `full-moon-behavior` multimethod that dispatches on the `:were-type` key of a map. The code uses `defmulti` with a custom dispatching function and `defmethod` to attach behavior for `:wolf` and `:simmons` types, returning strings based on the creature’s name. Calling the multimethod with different maps, as shown, produces type-specific output. The example is drawn from a Clojure documentation gist, demonstrating dispatch logic without any external visualization libraries or data sources.

EEleonore9

49% match