Power Query Functions That Return Functions

You’re probably aware that, in Power Query, a query can return a function. So for example here’s a very simple query (so simple that no let statement is needed) called MultiplyTwoNumbers with the following definition:

(x as number, y as number) => x * y

It can be used on the following table in Excel:

…to multiply the numbers in the column called Number by two and show the result in a custom column like so:


Source = Excel.CurrentWorkbook(){[Name=”Data”]}[Content],

#”Inserted Custom” = Table.AddColumn(Source, “Custom”, each MultiplyTwoNumbers(2, [Number]))


#”Inserted Custom”

Here’s the output:

It’s also the case that a function can return another function. Consider the following query, called MultiplyV2:


EnterX = (x as number) =>


EnterY = (y as number) => x * y





It is a function that takes a single parameter, x, and it returns a function that takes a single parameter, y. The function that is returned multiplies the value of x by the value of y. Here’s an example of how it can be used on the table shown above:


//Return a function that multiplies by 2

MultiplyBy2 = MultiplyV2(2),

//Load data from the table

Source = Excel.CurrentWorkbook(){[Name=”Data”]}[Content],

//Use the MultiplyBy2 function in a custom column

#”Inserted Custom” = Table.AddColumn(Source, “Custom”, each MultiplyBy2([Number]))


#”Inserted Custom”

This gives exactly the same result as before:

In this query, the MultiplyBy2 step calls the MultiplyV2 function with the argument 2, and this returns a function that multiplies the values passed to it by 2. This function can then be called in the final step where the custom column is added to the table using the expression MultiplyBy2([Number])

Interesting, isn’t it? I hope this satisfies your curiosity Marco J

You can download the sample workbook for this post here.



13 thoughts on “Power Query Functions That Return Functions

  1. This is a sorely overlooked feature of the M language which is a missed opportunity for Mister-softee IMHO. At first this seems like a neat trick, but using this process enables a lot of functionality and ease of development. This allows users to break big complex behaviors down into manageable snippet functions. I would love to hear more on the topic.

  2. Thanks for this inspiring post.It has helped me find the solution to the following case: I needed to import data from Excel reports in a folder. These reports come in 4 different formats. I therefore created 4 functions to import each format. With the technique described in the post, I have created a wrapper function that returns the import function corresponding to the format parameter.

  3. Hi Chris,

    I have this problem.
    A b c d e
    Row1 1 2 3 3 1

    Read and output as:

    Has only 1 = 300 rows
    has 1 and 2 = 200 rows
    has 1 and 3 = 100 rows
    has 2 and 3 no1 = 50 rows

    I used to add column and do countif in normal excel work well but not scalable. Still pulling my hair off to get this done through Power Query.

  4. Hi Chris
    A b c d e f
    Row1 1 2 3 3 3 1

    I need to out put this table

    The program need to read through column a-f of each row and summarize:
    Has only 1 = 500 rows
    has 1 and 2 and no3 = 300 rows
    has 1 and 3 and no 2 = 200 rows
    has 2 and 3 and no1 = 100 rows

    I used to do countif for each condition via normal excel. But for power query. Still pulling my hair off.

  5. Great how to… thank you.

    Can you invoke a function from another query to create a column in that query… if so how is the syntax different?

    Sorry for the rookie question.

    • Thomas:

      The trick with writing good functions to use for adding columns is that you often want to examine multiple fields in each row (e.g. if column A is true then column B * Columns C else Column B * [Value from some External Source]).

      This sort of problem requires more tinkering when creating an invoke-able function – namely, your function should take a record as input. This way, you can call the function and pass the entire row (which is a record) to the calling function. The the step to call the function to add a row will look like this:

      myStep = Table.AddColumn(prevStep, “myColumnName”, each myFunction(_))
      *caveat ‘each’ may not be required

      The external function might take on a form like this:

      myFunction // saved as separate query/function

      (myRecord as record) =>

      checkColA = myRecord[Column A] = “something”, // test that gives true or false,
      results = if CheckColA
      then myRecord[Column B] * myRecord[Column C]
      else myRecord[ColumnB] * List.Sum(myExternalSource)
      in results

      This technique works really well for separating the function logic out so that it can be worked on as it’s own separate function. The one issue that I have run into is that as your function starts calling external data sources and when you are calling it for tables with lots of rows, the overall query will get very ‘chatty’ (read: slow).

      The best way around this is to find points to buffer in external sources I THE CALLING QUERY, that way these stay in memory ad don’t need to be repeatedly accessed for each row. Not sure how technically accurate my description is – but there is definitely room for optimization if you find these taking longer than you think they should.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s