A `.split()` function for excel—assumes 0 index, "-" delimiter, and reference cell "A2" but are all customizable. Outputs a string representation of the formula

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.

42% match

excel_function_BW2

This example displays a single computed revenue projection as a text value in the browser, annotated with “$ USD”. It calculates the number by running a complex statistical predictor function with fifteen hard-coded input parameters, combining logistic regression for sellout probability with separate regression models for expected gross and standard deviation, then scaling those against weekly averages. The visualization uses D3.js version 3.5.5 to append the result to the page, while all calculations rely on raw JavaScript math functions. No external data source is loaded; the input values and weekly benchmark figures are defined as variables in the code.

BBenHeubl

Power Query regex example from http://www.thebiccountant.com/2018/04/25/regex-in-power-bi-and-power-query-in-excel-with-java-script/

This example demonstrates how to extract numeric patterns from a mixed-language string using regular expressions within Power Query. It defines a custom function that invokes JavaScript’s `RegExp` and `String.match` via the `Web.Page` HTML/JavaScript execution environment, passing a target string and a regex pattern. The specific call extracts all digit sequences from “hello012中国1235” and returns them as a list. This approach highlights Power Query’s ability to leverage external scripting for text processing, bridging M’s native functions with JavaScript’s regex engine for advanced pattern matching.

Created on Cognitive Class Labs

This notebook from a Cognitive Class Labs course demonstrates Python string operations, including indexing, negative indexing, slicing, stride, concatenation, escape sequences, and string methods. The examples show how to define strings with single or double quotes, combine spaces, digits, and special characters, and apply methods like `upper()`, `replace()`, and `find()`. The code is executed in Jupyter cells, with outputs displayed inline as executed results, and the notebook is sourced from a gist authored by DAVINDERYADAVRJIT.

DDAVINDER

Gist d2f55e96546318a1e8e393d423ea36e9

This example shows a SQL query that transfers data from one Excel sheet to another, creating a new table in a separate workbook file. The visualization demonstrates how data can be exported or copied between spreadsheet locations using an embedded query. The code uses the `SELECT * INTO` syntax with an `[Excel 8.0;DATABASE=...]` connection string, specifying the destination file path and sheet name. The query pulls all records from the source sheet and writes them to the target workbook, illustrating a straightforward data-migration pattern. The rendering approach relies on the database driver’s handling of the Excel file format, with no additional charting or graphics libraries involved.

HEX2DEC one liner implementation in Power Query M

This example demonstrates a compact implementation of hexadecimal-to-decimal conversion in Power Query M, a formula language used in Microsoft Power BI and Excel. It shows how a single-line function can replace a multi-step conversion process. The code defines a custom function named `HEX2DEC` that takes a text string as input and applies the `Expression.Evaluate` API with the literal prefix “0x” to interpret the hexadecimal value. The function then returns the decimal result directly. The visualization highlights the elegance of using M’s expression evaluation for parsing, offering a practical alternative to built-in conversion functions.

40% match

Extract the first character of each string part separated by the '-'. There can be an unknown number of potential parts.

This example demonstrates how to extract the first character of each string segment separated by hyphens, regardless of the number of segments, and concatenate them into a single output. It shows a concise SQL pattern for parsing structured text data. The query uses PostgreSQL’s `regexp_matches` function with a global flag to find all alphanumeric characters, then aggregates the results with `array_agg` and converts the array to a string via `array_to_string`. The source data, ‘Letter-1-2’, is processed to yield the abbreviated result, highlighting the reusable regex and array functions for dynamic text parsing.

CCaged

40% match

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