[PowerQuery] Decompiling List.Range function

100%

[PowerQuery] Decompiling List.Range function

✓ Published0🌍 Public

Last edited Mar 12, 2018

Created on Mar 12, 2018

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Power Query attempt at decompiling a function call

This example shows a Power Query (M) custom function that decompiles a `List.Skip` call into its component parts—the list, the offset, and an optional count. It demonstrates how M’s standard library functions `List.Skip` and `List.FirstN` are composed to recreate the logic of a function call, with `skippedInput` holding the intermediate result after skipping a given number of elements. The code reveals the underlying structure of the operation by explicitly handling a null count fallback, which would otherwise be implicit in the original function. This visualization highlights the metaprogramming aspect of Power Query, where code itself is treated as data for inspection.

HHugoberry

67% match

Loading thumbnail…

RowExpression.From as JSON

This example demonstrates a Power Query M script that converts a `RowExpression` result into JSON text, revealing the internal structure of row and function type metadata. It shows how the script recursively normalizes values—turning tables, records, and lists into JSON-compatible forms while replacing functions and type values with descriptive strings. The code relies on the M standard library functions `Json.FromValue`, `Text.FromBinary`, and `Type.Is`/`Type.IsNullable` to map primitive and complex types to their JSON representations. It also uses table and record manipulation functions like `Table.TransformColumns`, `Record.FromList`, and `Type.FunctionParameters` to expose parameter details, required flags, and nullable status. The final output is a serialized JSON string generated from the evaluated expression.

HHugoberry

64% match

Loading thumbnail…

JSON expansion in Power Query M

This example demonstrates how to flatten or expand nested JSON structures using Power Query’s M language, specifically through the `List.Generate` function. It shows the step-by-step traversal of a record hierarchy, where each iteration checks whether the current value is a record, tracks the nesting level, and builds an output record that appends the field names discovered at each depth. The code relies on core M functions like `Record.FieldNames`, `Record.FieldValues`, and `Record.AddField`, along with list concatenation, to construct the expanded output. The visualization highlights a programmatic approach to transforming hierarchical JSON into a flat, tabular-friendly format, without external libraries.

HHugoberry

62% match

Loading thumbnail…

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.

HHugoberry

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

60% match

Loading thumbnail…

Power Query \Microsoft.Mashup.Document\Host\Document\Analysis\AddPartitionMetaDocumentAnalyzer.cs => BeginAnalyzeDocumentPartitions

This visualization shows how Power Query’s folding engine decides whether a query can be pushed to a data source, using a generated `Expression.m` file. The code inspects a table’s structure and metadata, removes columns of complex types, and then evaluates whether the resulting expression is a native query invocation. It relies on the Power Query M language’s `Table.FromValue`, `Table.RemoveColumns`, and `Value.ResourceExpression` functions to build and analyze the expression tree. The output is a record with `IsFolded` and `HasNativeQuery` flags, revealing whether the query is foldable and whether it uses a native query path. The data source is implicit, but the logic centers on the M expression’s `Kind` and `Arguments`.

HHugoberry

60% 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…

PowerQuery list functions cheat sheet

This example is a cheat sheet for Power Query's list functions, organized as a reference card with sections for addition, averages, generators, information, membership, numerics, ordering, and selection. It shows concise code snippets with sample outputs, such as List.Sum({1, 2, 3}) ⇒ 6 and List.Generate(() => 10, each _ > 0, each _ - 1) ⇒ {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}. The source is a gist by Hugoberry.

HHugoberry

59% match