Gist 10da47bd381918d303c5db903afe5886

Gist 8abd0d0a72b91b4d72ce79ac9d8ab6c4

This example demonstrates how Power Query’s `BinaryFormat.List` function reads binary data as a sequence of items, returning a list. It shows three distinct modes: reading until the data ends, reading a fixed number of items, and using a condition function to stop based on item values. The code constructs sample binary data with `#binary`, then applies `BinaryFormat.List` with `BinaryFormat.Byte` as the item format. The condition variant passes a lambda `(x) => x < 2` that continues reading while true, including the first failing item. The output lists (e.g., `{1, 2, 3}`) directly display the parsed bytes.

64% match

CRC32 implementation in Power Query M mostly inpired by the article about CRC32 computation http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html and Bit Hacks https://graphics.stanford.edu/~seander/bithacks.htm

This example demonstrates a complete CRC32 implementation written in Power Query M, showing how to compute cyclic redundancy checks entirely within a data-transformation language. It displays both the algorithm’s core logic and its practical output as a hexadecimal checksum. The code defines a reverse function for 8-bit and 32-bit values, precomputes a lookup table using a polynomial of 0x4C11DB7, and iterates over input characters with an accumulator function. It relies on Power Query’s `Number.BitwiseAnd`, `Number.BitwiseShiftLeft`, `Number.BitwiseXor`, and `List.Accumulate` APIs. The final result reverses the raw CRC, XORs with 0xFFFFFFFF, and formats it as uppercase hex via `Number.ToText`. The source is a gist by Hugoberry, drawing from external CRC tutorials and bit-hack references.

Generating Mandelbrot set in Power Query

This example renders the Mandelbrot set entirely within Power Query by generating a 1080-point sequence with `List.Generate`, mapping each point to the complex plane, and iterating the classic Mandelbrot formula to compute escape values. It visualizes the resulting 2D grid of iteration counts as a static bitmap, relying on Power Query’s built-in table and chart capabilities rather than external libraries. The code exposes a compact, functional approach to fractal generation, directly showing how iteration-based math translates into a visual image without specialized graphics APIs.

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.

DEC2BIN or HEX2BIN in Power Query M

This example demonstrates a Power Query M function that converts a decimal number to its binary string representation, implementing the equivalent of Excel’s DEC2BIN and HEX2BIN operations. The function, `Number.DEC2BIN`, takes a numeric input and uses `List.Generate` to iteratively extract bits via `Number.BitwiseAnd` and `Number.BitwiseShiftRight`. Each iteration prepends the least significant bit to an accumulating string, while the loop continues until the remainder becomes zero. The code relies on M’s native `Number.ToText` for bit conversion and explicitly shows the bitwise arithmetic and list-generation logic, with no external libraries or data sources involved.

PowerQuery List functions with unicode examples

This cheat sheet visually maps Power Query's list functions using geometric unicode symbols as both data and output markers. It organizes functions into categories like Generators, Selection, and Ordering, with each entry showing a call and its returned list. The examples highlight type-specific behaviors, such as `List.Zip` combining symbols into pairs, `List.Sort` deduplicating while ordering, and generator functions producing date, time, and numeric sequences. Unicode shapes make the transformations immediately legible, turning the snippet into a compact reference for list operations.

60% match

Gist 67bf315eb5b9cafa9a5899b88f252dab

This example shows a bill-of-materials (BOM) data-transformation pipeline, expanding each assembly component by a numeric factor to generate multiple line-item rows. The Power Query M code in `BOMsourcer.pq` duplicates rows based on the `Factor` column, then reconstructs hierarchical identifiers by concatenating `ProductAssemblyID`, `ComponentID`, and the expanded custom counter using text delimiters (`.`, `:`) via `Table.CombineColumns` and `Table.ExpandListColumn`. It renames and reorders columns, casts date and numeric types, and merges component and product fields into single keys, ultimately preparing the data for downstream visualization or analysis. The visible operations rely on standard Power Query table functions rather than a specific charting library.

59% match

Gist a25bf43fbc2ada9a1cc29f874f509134

This example shows a Power Query custom function that extracts list items by their numeric positions, returning a new list with only the selected elements. The function `List.SelectPositions` takes a source list and a list of indices, with an optional parameter to shift the starting index from zero-based to one-based numbering. It uses `List.Transform` with a buffer for performance, applying `_{_ + StartPosition}?` to safely handle out-of-range positions by returning null. The implementation relies on the standard Power Query `List` and `Value` APIs, including `Value.ReplaceType` and `Value.ReplaceMetadata` to attach documentation and usage examples.