let r = { string in
  string.rangeOfString("l{2}",
    options: [.RegularExpressionSearch],
    range: string.startIndex..<string.endIndex,
    locale: nil)
  }("Hello")

One way to be less clunky: Don’t call the full method if you are just going to be supplying default arguments anyway.

let r = “Happy”.rangeOfString(“p{2}”, options: [.RegularExpressionSearch])

I’d love anyGenerator{static n = 0; return n++} too! I just had some code that needed closure state.

I think your with(args) {} could be done as:

func with1(v1: T1, f:(T1) -> (U)) -> U {
    return f(v1)
}

func with2(...) -> U { ... }

...

with1("Hello") {
    $0.rangeOfString("l{2}",
        options: [.RegularExpressionSearch],
        range: $0.startIndex..<$0.endIndex,
        locale: nil)
}

For this specific example, it’s definitely worth noting that the string search methods in the Foundation overlay have default arguments for range and locale that would make this entire thing moot. (Not that this isn’t worth talking about for other cases.)

i’ve been using a couple of operators for this:

    infix operator ->- {
        associativity left
        precedence 95
    }
    
    func ->-  (value: T, @noescape fn: T -> U) -> U {
        return fn(value)
    }
    
    infix operator -=- {
        associativity left
        precedence 95
    }
    
    func -=-  (var value: T, @noescape fn: inout T -> Void) -> T {
        fn(&value)
        return value
    }
    
    func -=-  (value: T, @noescape fn: T -> Void) -> T {
        fn(value)
        return value
    }

the first does what you describe here, you could write

“Hello” ->- {
$0.rangeOfString(“l{2}”,
options: [.RegularExpressionSearch],
range: $0.startIndex..<$0.endIndex,
locale: nil)
}

the second is basically a little shortcut for when you'd be doing return $0 with the other one – e.g. if you're taking some struct or object and changing some fields and then returning the same object (or modified value of same type). it captures changes to value types by making the implicit $0 argument an inout in that case. i've found this operator handy for initializing complex Cocoa objects.

they're both left-associative at the same precedence, so they should work as expected if you use them in a shell-like pipe chaining style.

The anonymous closure trick is neat, but it has a problem where Swift does not (currently) infer anonymous closures like that to be @noescape. I’d recommend using a with() function, as you suggested. You don’t even need multiple functions like Keith suggested, a single generic function can accept a tuple.

And in fact, it turns out the Swift standard library already has a with function. Except it’s actually called withExtendedLifetime, because the purpose of the function is just to ensure the value is not destroyed before the closure finishes executing. But it turns out to have precisely the method signature we already want. So if you don’t mind the typing, you can use it like

withExtendedLifetime("Hello") {
    $0.rangeOfString("l{2}",
        options: [.RegularExpressionSearch],
        range: $0.startIndex..<$0.endIndex,
        locale: nil)
}

Although there is one improvement we could make, which is to make it rethrows. As I understand it, the Swift standard library currently doesn’t make use of rethrows because of compiler bugs, but this is what it would look like:

func with(x: T, @noescape f: T throws -> Result) rethrows -> Result {
    return try f(x)
}

with("Hello") {
    $0.rangeOfString("l{2}",
        options: [.RegularExpressionSearch],
        range: $0.startIndex..<$0.endIndex,
        locale: nil)
}

And actually, this right here demonstrates a compiler bug around rethrows, which is that it infers the anonymous closure to be throws even though it can’t actually throw, and so emits an error saying you need try.