infix-operator

I'm trying to understand the implementation of List s in Scala. In particular I'm trying to get my head around how you can write match expressions using an infix operator, for example: a match { case Nil => "An empty list" case x :: Nil => "A list without a tail" case x :: xs => "A list with a tail" } How is the match expression allowed to be x :: xs rather than List(x, xs) ? Daniel Spiewak Jay Conrad's answer is almost right. The important thing is that somewhere there is an object named :: which implements the unapply method, returning type Option[(A, List[A])] . Thusly: object :: { def

A little bit of context first... I've written an infix function that in essence replaces the idiom x[[length(x) +1]] <- y ..or simply x <- append(x, y) for vectors. Here it is: `%+=%` <- function(x, y) { xcall <- substitute(x) xobjname <- setdiff(all.names(xcall), c("[[", "[", ":", "$")) # if the object doesn't exist, create it if (!exists(xobjname, parent.frame(), mode = "list") && !exists(xobjname, parent.frame(), mode = "numeric") && !exists(xobjname, parent.frame(), mode = "character")) { xobj <- subset(y, FALSE) } else { xobj <- eval(xcall, envir = parent.frame()) } if (is.atomic(xobj)) {

Methods taking a single argument can be written as an infix operators in Scal. I.e. adding *(other:C) = foo(this, other) to class C, will allow us to write c1 * c2 instead of foo(c1,c2). But is there a way to define infix operators on existing classes that you cannot modify? E.g. if I wanted to write c1 + c2 instead of xor(c1,c2) , where c1,c2:Array[Byte] , I obviously cannot modify the Array-Class. I found this and tried implicit class Bytearray(a1:Array[Byte]) extends Anyval { def +(a2:Array[Byte]) = xor(a1,a2) } But that doesn't seem to work ( c1 + c2 ). Type mismatch, expected:String,