Skip to main content
SimilarExport ZIP
100%

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

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

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.

AI-generated description

Similar vizzes

Loading thumbnail…

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

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.

HHugoberry
67% 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
64% 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
62% 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
62% 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
61% match
Loading thumbnail…

[PowerBI/PowerQuery] Function that translates the documentation attached to a function definition into Markdown text

This example demonstrates a Power Query function that converts the documentation embedded in a function’s type metadata into a Markdown-formatted text block. It first retrieves the function from Power BI’s shared namespace, then extracts fields such as description, long description, category, and examples from the `Value.Metadata` of the function’s type. The code handles missing fields with `try`/`otherwise`, and uses `Text.Trim`, `Lines.ToText`, and `List.Transform` to assemble a template with headers and code fences. The final output is a Markdown document suitable for gallery display, relying solely on the function’s own metadata as the data source.

HHugoberry
60% 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
59% 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
57% match