[Power Query] Decorate a function parameter with allowed values {1..9}

100%

[Power Query] Decorate a function parameter with allowed values {1..9}

✓ Published0🌍 Public

Last edited Oct 14, 2017

Created on Oct 14, 2017

This example demonstrates a custom Power Query function parameter decorator that restricts input values to the range 1 through 9. It shows how a function like `fnCopy` can be wrapped with `setParameters(fn, {1..9})` to enforce allowed numeric values, improving type safety and self-documentation. The code relies on Power Query’s native function-handling APIs, specifically `setParameters`, which validates and assigns metadata to the parameter. The visualization likely displays the decorated function’s behavior in a query editor, with the allowed range visible as part of the parameter definition. No external rendering libraries are used; the example focuses on the query logic itself, not on graphical output.

AI-generated description

Similar vizzes

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

72% 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

71% match

Loading thumbnail…

[Power Query] Replace an unary function type with a custom type that contains metadata for allowed parameter values

This example demonstrates how to replace an unary function type with a custom type that carries metadata for allowed parameter values. The code defines a function `setParameters` that accepts a function `f` and a list `allowedValues`, then constructs a new parameter type using `Value.Type` and attaches documentation metadata via `meta`. It builds a function type with `type function` and applies it using `Value.ReplaceType` to modify the original function’s type. The implementation relies on Power Query’s `Value.Type` and `Value.ReplaceType` APIs, with metadata defined by `Documentation.AllowedValues` for parameter validation.

HHugoberry

67% 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

64% match

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

63% match

Loading thumbnail…

[Power Query] function curry with up to N levels and maintaining function signature types

This example demonstrates a Power Query function named `Function.CurryN` that enables currying of any function with up to N argument levels while preserving the original function's type signature. It shows how the function dynamically inspects the input function's parameter metadata via `Type.FunctionParameters` and `Type.FunctionRequiredParameters` to determine arity, then recursively builds and invokes intermediate closures using `Function.From` and `Function.Invoke`. The test file `test.pq` applies this to `Text.Contains`, first without a specified N (currying all three parameters), then with explicit N values of 2 and 1, illustrating flexible partial application. The implementation relies on Power Query's standard library functions like `Record.SelectFields` and `Type.ForFunction` to manage type safety across each curry level.

HHugoberry

59% match

Loading thumbnail…

[Power Query] Closures, partial application and cascading parameters

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.

HHugoberry

59% 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

56% match