Skip to main content
SimilarExport ZIP
100%

[Power Query] Closures, partial application and cascading parameters

✓ Published0🌍 Public
HHugoberry
Last edited Oct 14, 2017
Created on Oct 13, 2017

This example demonstrates how Power Query’s M language implements closures and partial application through nested functions. The code defines `addTo` as a function that returns another function, capturing the outer variable `x`. By calling `addTo(5)`, it creates `addToFive`, a closure that retains the value 5 in its scope. When `addToFive(3)` is invoked, the closure evaluates to 8, showing how cascading parameters flow through each layer. The rendering is purely textual, with no external libraries or data sources; the logic itself is the visualization.

AI-generated description

Similar vizzes

Loading thumbnail…

[Power Query] Closures, partial application and cascading parameters

This example shows how Power Query applies functional techniques to build a cascading parameter system, where a selection in one step narrows the choices in the next. It demonstrates closures and partial application by defining a function `fn.ts` that takes an initial parameter `x` and returns a second function awaiting `y`, ultimately computing their product. The visualization uses this pattern to drive linked dropdowns or sliders, where the output of one control feeds directly into the next. The code relies on Power Query’s native M language functions for data shaping, with no external libraries, and the rendering approach is not specified in the provided snippet.

HHugoberry
90% match
Loading thumbnail…

[Power Query] Closures, partial application and cascading parameters

This example demonstrates a data-visualization technique that uses Power Query’s `setParameters` function to create cascading parameters through closures and partial application. The code shows how a function `_fn_` is wrapped in a closure, where `fnCopy` is defined as `(x) => setParameters(fn(x),{1..x})`, allowing dynamic parameter injection. The outer call `setParameters(fnCopy,{1..9})` further restricts the parameter set, illustrating nested parameter scoping. The visualization itself is not a chart but a programmatic pattern for controlling function behavior, relying on Power Query’s M language rather than a graphical library. It highlights how parameter cascading can be achieved without external data sources or rendering, focusing on functional composition.

HHugoberry
87% match
Loading thumbnail…

[Power Query] Closures, partial application and cascading parameters

This example shows how Power Query’s cascading parameters control a dynamic data-filtering workflow. The code defines a closure that partially applies a filter function, returning a new function for later invocation. Using the M language’s `Function.Invoke` and `List.Select` APIs, it passes a column value into a nested lambda, demonstrating how parameter values flow through successive scopes. The gist’s `fn.ts` file illustrates the pattern with a simple identity function, while the visible M code applies this pattern to filter table rows based on a stored parameter. The approach highlights how Power Query’s functional composition enables reusable, parameter-driven query logic without hard-coding values.

HHugoberry
87% match
Loading thumbnail…

[Power Query] [m] Closures

This example visualizes the inner workings of a TypeScript-based function-closure mechanism, showing how parameter lists are programmatically overwritten and restricted. It demonstrates the step-by-step process of copying a function (`fnCopy`) and applying `setParameters` to limit its arguments to a specific range, then wrapping that operation with another `setParameters` call to further constrain the allowed parameter indices to 1–9. The code uses TypeScript’s type system and higher-order functions (like `setParameters`) to manipulate closures at runtime. The rendering approach is textual, highlighting the sequential logic through code snippets, with no graphical or data-driven output beyond the functional transformation.

HHugoberry
79% match
Loading thumbnail…

Example of a closure function in Power Query

This example shows a closure function in Power Query, where a nested function returns another function that captures and returns a value. The code defines a `ring` function that, when called, produces another function; invoking the first call returns the inner function, and the second call retrieves the `Answer` record. It demonstrates the mechanics of closure and deferred execution, using Power Query’s `let` and `in` syntax. The data source is a hardcoded record, and the rendering is not applicable, as the output is a text result.

HHugoberry
70% match
Loading thumbnail…

[Power Query] Experimenting with thunks and trampolines

This example demonstrates a manual implementation of tail-call optimization using thunks and a trampoline, written entirely in Power Query. It shows how recursive functions can be restructured to avoid stack overflow by wrapping each recursive call in a thunk—a zero-argument function—and then driving the computation forward with a trampoline that repeatedly invokes the current thunk until a non-function value is produced. The code defines two custom functions: `make_thunk.pq`, which uses `Function.Invoke` to delay a function call, and `trampoline.pq`, which uses `List.Generate` with type checking via `Type.Is` and `Value.Type` to iterate until the result is no longer a function. The example highlights a purely functional, dataflow-driven approach to control flow, with no external libraries or visual rendering, relying solely on Power Query’s standard library.

HHugoberry
67% match
Loading thumbnail…

Gist f3a61a41e6832de955bdf750f4c54ba3

This example demonstrates a custom Power Query function that multiplies its input by a metadata value retrieved from a previously invoked function. The visualization shows how dynamic metadata can influence computed results within a data transformation pipeline. The code uses the `Expression.Evaluate` API to access the `Value.Metadata` function, pulling the `[a]` field from shared context, then multiplies that value by the parameter `x`. The rendering approach is not visual; instead, it highlights programmatic data shaping in Power Query, with the function `fn.pq` serving as the core logic. The source is a single gist file authored by Hugoberry.

HHugoberry
66% 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
64% match