Pipe forward operator and curried free functions = fluent interface

100%

Pipe forward operator and curried free functions = fluent interface

✓ Published0🌍 Public

Last edited Mar 20, 2015

Created on Mar 20, 2015

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.

AI-generated description

Similar vizzes

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

55% match

Loading thumbnail…

A demonstration of Swift sequences

This example demonstrates Swift sequences by pairing odd and even Fibonacci numbers, then skipping the first two pairs before printing the next two results. The code defines custom Fibonacci sequences, uses the `filter` function to generate separate odd and even number streams, and combines them with `Zip2`. A `skip(n:)` extension on `SequenceOf` filters out leading elements, while `GeneratorOf` lazily produces values. The output logs each generated Fibonacci number and the skipped pairs, showing how sequence composition and lazy evaluation work together in Swift.

CColinEberhardt

51% match

Loading thumbnail…

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.

FFranklin Chen

50% match

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

50% match

Loading thumbnail…

Gist 3908cc252b823e449510

This example demonstrates a Swift extension that removes duplicate elements from an array of strings, converting the initial list containing repeated values like "P" and "C" into a unique sequence. The custom `unique()` method uses the standard library’s `reduce` function alongside a generic `contains` check to build a filtered result. The code explicitly converts each element to a generic type `T` and appends it only if it is not already present. The final output, printed via `println()`, shows the deduplicated array in its original order, preserving the first occurrence of each string.

CColinEberhardt

49% match

Loading thumbnail…

A set of pure and immutable ES2015 functions aimed to make functional JavaScript more idiomatic.

This example presents a collection of pure, immutable ES2015 utility functions for idiomatic functional JavaScript. It includes array operations such as `combine`, `compact`, `difference`, and `intersection`, object helpers like `merge` and `toMap`, math functions (`min`, `max`, `sum`, `product`), and function decorators including `curry`, `once`, `maybe`, and `pipeline`. The code relies on native JavaScript features like `Array.prototype.includes`, `Set`, `Map`, `Object.assign`, and spread syntax. No external libraries or data sources are used; the gist demonstrates standalone, reusable functional patterns.

JJaxonDvl

49% match

Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt

48% match

Loading thumbnail…

Simple examples of higher-order functions and partial function application in XQuery

This example demonstrates higher-order functions and partial application in XQuery 3.0, using code tested with Saxon and Zorba. It shows functions that accept or return other functions, such as `local:pow` returning a function, and the `math:pow#2` built-in being partially applied with `?`. The code also illustrates fold operations (`fold-left`, `fold-right`) and sequence functions (`for-each`, `for-each-pair`, `filter`), applied to string and integer sequences. These snippets highlight how XQuery 3.0 supports functional programming patterns.

CCliffordAnderson

48% match