Environments in Power Query. What is k?

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.

60% match

R flavoured Kmeans algorithm in Power Query

This example demonstrates the R-flavored K-means clustering algorithm executed directly within Power Query, using the iris dataset’s petal width and length columns to assign cluster memberships. The visualization shows the resulting iris data points colored by their assigned cluster, with the clustering computed in R via the `kmeans` function and seeded for reproducibility. The Power Query M code invokes the R engine through the `R.Execute` API, passing a script that runs K-means with three centers and twenty random starts, then returns the augmented table containing the cluster labels. The underlying data originates from the built-in iris dataset, and the rendering relies on Power Query’s native table output, not a separate charting library.

55% match

[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.

54% match

[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.

54% match

[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.

[PowerQuery] Decompiling List.Range function

This example shows how to decompile the Power Query `List.Range` function into its underlying expression tree, revealing the nested structure of arguments and function bodies. It uses the `Value.ResourceExpression` API to access the function’s AST, then recursively traces and serializes the structure via `Json.FromValue`, with helper logic that converts values, types, lists, and records into a JSON-compatible format. A second expression, `DeepDecompile.pq`, directly navigates the resource expression’s `[Expression][Arguments]{0}[Function][Expression][Expression]` path to extract the innermost function body. The visualization renders the resulting JSON as a plain-text trace, highlighting the difference between high-level metadata lookup and low-level AST traversal.

Power Query navigate the documentation of #shared functions. [M code]

This example visualizes the complete set of functions exposed by Power Query’s `#shared` namespace, organized into a navigable table. It shows each function’s name, module, category, example code, description, and signature. The M code uses `Record.ToTable` and `Table.SelectRow` to filter functions, then leverages `Value.Metadata` to extract documentation fields like `Documentation.Category` and `Documentation.Examples`. It also parses module names via `Text.Split` and builds signatures dynamically. The result is a self-documenting inventory, enabling users to browse and understand the entire Power Query function library directly from the environment.

Dissecting ZIP file structure in Power Query M following explanation from https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html

This example dissects the binary structure of ZIP files using Power Query’s M language, following the PKZIP format specification from James Madison University. It visually parses a ZIP file’s local file headers, central directory entries, and end-of-central-directory records, revealing metadata like compression method, timestamps, and file names. The code leverages `BinaryFormat` combinators—such as `BinaryFormat.Record`, `BinaryFormat.Choice`, and `BinaryFormat.List`—to sequentially read and interpret byte streams, with `Binary.Decompress` handling deflate decompression. The visualization highlights how raw bytes map to structured fields, making the format’s internal layout explicit. Data originates from a sample ZIP file provided as a binary input.