Is it possible to write an expression macro in Swift to curry any function?

Question

Let's say I would have this function:

enum HttpMethod: String { case get, post, put, patch, delete }

func makeRequest(
    method: HttpMethod,
    baseURL: URL,
    pathSegments: [CustomStringConvertible] = [],
    headers: [String:String] = [:],
) -> Response {}  // body is not important

What I would like, if it were possible, is to have an expression macro called #curry that does something like this:

// Every underscore signifies that that parameter
// should still be fillable in the newly generated function
let makeRequestToMyApi = #curry(makeRequest(
    method: _,
    baseURL: "https://example.com/api",
    pathSegments: _,
    headers: _,
))

let me = makeRequestToMyApi(
    method: .get,
    pathSegments: ["users", "me"],
    headers: ["Authorization": "Bearer blabla"],
)

And if a parameter that has a default value defined in the function definition (e.g. headers), is not given an underscore during the currying, then it should be assumed that that parameter should just be filled with its default parameter. And therefor no longer available to get filled later. Like so, for example:

let makeRequestToMyApi = #curry(makeRequest(
    method: _,
    baseURL: "https://example.com/api",
    pathSegments: _,
    // notice that headers is missing here,
    // since it was not marked with an _,
    // it will be assigned its default value
))

let me = makeRequestToMyApi(
    method: .get,
    pathSegments: ["users", "me"],

    // This would cause an error, because headers is not available to fill,
    // because headers was already assigned its default value of [:]
    headers: ["Authorization": "Bearer blabla"],
)

Is it possible to write an expression macro that does exactly this?

Answer 1

It's not possible to make a macro for this because it's not possible to write it by hand. Consider a simpler function:

func f(x: Int, y: String) -> String { "\(x)\(y)" }

I want to partially apply x, leaving a function (y: String) -> String:

func f(x: Int) -> ((y: String) -> String) { { y in f(x: x, y: y) } }

With this, I could call:

let fx = f(x: 1)
fx(y: "one")

But that's not valid Swift. It'll give two errors:

Function types cannot have argument labels; use '_' before 'y'

And then:

Extraneous argument label 'y:' in call

Swift does not support argument labels in function types.

var f: (Int) -> String    // This is allowed
var g: (x: Int) -> String // This is not

So there is no kind of expression macro that can build this. There's nothing it can expand to.

I've been thinking a lot about how this might be written as a declaration macro, but even if it is possible (I'm still exploring), it's not going to be in the spirit of your example. It might be possible to have a macro that works like this:

// This particular syntax is probably impossible, but as an idea
#partial("makeRequestToMyApi", makeRequest, baseURL: "https://example.com/api")

And that might expand to, in the best of possible worlds:

func makeRequestToMyApi(method: HttpMethod,
    pathSegments: [CustomStringConvertible] = [],
    headers: [String:String] = [:],
) -> Response {
    makeRequest(method: method, 
                baseURL: "https://example.com/api", 
                pathSegments: pathSegments,
                headers: headers)
}

But even if that's possible, you'll notice that it declares a function. That means it has to be done at compile time, so "https://example.com/api" has to be a string literal in your source code.

I don't think anything more dynamic than that can exist. Again, not because of macros but because of the syntax of closures. You just can't have named parameters in them, which blows up your goal.

It might be possible to construct an expression macro that returns a closure that takes a tuple of the rest of the parameters, but that would be pretty bad for Swift. And in your specific example would break the default parameters. It might be interesting to try to build (and I'm continuing to mess around with it), but I can't see how it would be useful.

---

After some more messing around, I'm even more convinced this is impossible, and that the "why" is important.

Consider this code:

func f(x: Int, y: String) -> String { "\(x): \(y)" }

// Partially apply x=1 to f
func fx(y: String) -> String {
    f(x: 1, y: y)
}

Now try to get to the following macro syntax to generate fx:

#partial("fx", "f(x: 1, y: _)")

A lot of this is surprisingly possible. I've gotten this far (code at the end):

func \(raw: name)(y: String) -> String {
    \(raw: fn.calledExpression)(\(raw: passedArguments))
}

I'm sure with a few more minutes, I could get the y: in the signature. That's not hard.

But then we come to the complete roadblock. The String type for y and the return type -> String. These aren't expressed anywhere in the code calling the macro, so they're not possible to generate.

At macro expansion time, there's no context about other functions that exist. So there's no way to know the type of f. There's no way to interrogate its signature. It may not even be known at this point. It's all just tokens. I don't think it's possible to get much further, and I don't see that changing since this is a pretty big part of how Swift macros work.

Anyway, here's the code that gets this far. It is terrible code. I was just working out if it's possible, not writing code you should emulate.

// THIS IS TERRIBLE CODE. IT'S JUST TO SHOW WHAT CAN BE DONE
@freestanding(declaration, names: arbitrary)
public macro partial(_ name: String, _ fn: String) = #externalMacro(module: "PartialMacros", type: "PartialMacro")

public struct PartialMacro: DeclarationMacro {
    public static func expansion(
        of node: some SwiftSyntax.FreestandingMacroExpansionSyntax,
        in context: some SwiftSyntaxMacros.MacroExpansionContext
    ) throws -> [DeclSyntax] {

        guard let name = node.argumentList.first?.expression.as(StringLiteralExprSyntax.self)?.representedLiteralValue,
                let call = node.argumentList.dropFirst().first?.expression.as(StringLiteralExprSyntax.self)?.representedLiteralValue
        else { fatalError() }

        let syntax = Parser.parse(source: call)
        guard let fn = syntax.statements.first?.as(CodeBlockItemSyntax.self)?
            .item.as(FunctionCallExprSyntax.self) else { fatalError() }

        let passedArguments = LabeledExprListSyntax(
            fn.arguments.map {
                guard $0.expression.is(DiscardAssignmentExprSyntax.self) else { return $0 }
                return $0.with(\.expression, ExprSyntax(stringLiteral: $0.label!.text))
            })

        
        return [
            """
            func \(raw: name)(y: String) -> String {
                \(raw: fn.calledExpression)(\(raw: passedArguments))
            }
            """
        ]
    }
}

That said, this is just the extent of what is possible with a freestanding macro. I believe this is solvable with an attached macro, but it's even more useless for this purpose. You have to declare it as part of the function's definition. For example:

@partial("fx", x: 1)
func f(x: Int, y: String) -> String { "\(x): \(y)" }
...
print("fx = \(fx(y: "abc"))")

I believe this (or something like it) is possible, but it's definitely not what you want.