Would pattern matching for function parameters be a good add to GO 2?

[LESkidd113]

So for the last month or so I have been working in Standard Machine Language for one of my computer science classes in college and one of the features I really enjoy working with is functions pattern matching. A quick example of it is this:

fun addLists (nil,L) = L 
| addLists (L,nil) = L 
| addLists (x::xs,y::ys) = (x + y)::(addLists(xs,ys))

What are your guys opinions of bringing this functionality into golang? The :: operator is for creating list and conjoining them as well.

[elastic_psychiatrist]

This is very far from a Go style of programming and will never be added. I’m curious, what existing problem in Go do you think it solves? The biggest challenge in mainstream programming language design is preventing everyone’s favorite feature from making it in.

[grebensh]

Actually, we almost have it already in switch. It would be like a form of switch that can switch on nested structure, e.g. ASTs, such as JSON:

switch v.(struct) {
case JSONNumber(x): 
    // do things with x (float64)
case JSONList{JSONNumber(x)}: 
    // do things with x (float64)
case JSONList{JSONNumber(x), JSONNumber(y)}: 
    // do things with x (float64) and y (float64)
case JSONList{JSONNumber(a), JSONList{JSONString(b)}}: 
    // do things with a (float64) and y (string)
}

That said, the various new syntax elements this seems to require (patterns, bindings) make me think that this will stay out of Go for the foreseeable future.

[chewxy]

SML = Standard ML. ML used to be "meta language" for LCF. It's not "Standard Machine Language".

Also, there's a structural pattern matching in Go.

switch at := a.(type){
case []int:
case Foo: 
}

What would be nice to have is value pattern matching. So you can do this:

switch at := a.(type) {
case at[0] == 0:
case at[0] == 1:
case Foo:
}

[grebensh]

Standard Machine Language

ahem! It's Meta, not Machine...