* Added an experimental feature suggested by Andres: ellipses ("...")

  in attribute set pattern matches.  This allows defining a function
  that takes *at least* the listed attributes, while ignoring
  additional attributes.  For instance,

    {stdenv, fetchurl, fuse, ...}:
    
    stdenv.mkDerivation {
      ...
    };
    
  defines a function that requires an attribute set that contains the 
  specified attributes but ignores others.  The main advantage is that
  we can then write in all-packages.nix

    aefs = import ../bla/aefs pkgs;

  instead of

    aefs = import ../bla/aefs {
      inherit stdenv fetchurl fuse;
    };

  This saves a lot of typing (not to mention not having to update
  all-packages.nix with purely mechanical changes).  It saves as much
  typing as the "args: with args;" style, but has the advantage that
  the function arguments are properly declared (not implicit in what
  the body of the "with" uses).

7 files changed, 37 insertions, 18 deletions

diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
index ebcbac5391c9..e79d42504d0a 100644
--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -84,11 +84,12 @@ static void patternMatch(EvalState & state,
     ATerm name;
     ATermList formals;
     Pattern pat1, pat2;
+    ATermBool ellipsis;
     
     if (matchVarPat(pat, name)) 
         subs.set(name, arg);
 
-    else if (matchAttrsPat(pat, formals)) {
+    else if (matchAttrsPat(pat, formals, ellipsis)) {
 
         arg = evalExpr(state, arg);
 
@@ -122,8 +123,8 @@ static void patternMatch(EvalState & state,
         }
 
         /* Check that each actual argument is listed as a formal
-           argument. */
-        if (attrsUsed != nrAttrs)
+           argument (unless the attribute match specifies a `...'). */
+        if (ellipsis == eFalse && attrsUsed != nrAttrs)
             throw TypeError(format("the function does not expect an argument named `%1%'")
                 % aterm2String(attrs.begin()->key));
     }
@@ -402,9 +403,10 @@ Expr autoCallFunction(Expr e, const ATermMap & args)
     Pattern pat;
     ATerm body, pos;
     ATermList formals;
-
+    ATermBool ellipsis;
+    
     /* !!! this should be more general */
-    if (matchFunction(e, pat, body, pos) && matchAttrsPat(pat, formals)) {
+    if (matchFunction(e, pat, body, pos) && matchAttrsPat(pat, formals, ellipsis)) {
         ATermMap actualArgs(ATgetLength(formals));
         
         for (ATermIterator i(formals); i; ++i) {
diff --git a/src/libexpr/expr-to-xml.cc b/src/libexpr/expr-to-xml.cc
index 6ec906356a68..e401001ead01 100644
--- a/src/libexpr/expr-to-xml.cc
+++ b/src/libexpr/expr-to-xml.cc
@@ -45,15 +45,17 @@ static void printPatternAsXML(Pattern pat, XMLWriter & doc)
     ATerm name;
     ATermList formals;
     Pattern pat1, pat2;
+    ATermBool ellipsis;
     if (matchVarPat(pat, name))
         doc.writeEmptyElement("varpat", singletonAttrs("name", aterm2String(name)));
-    else if (matchAttrsPat(pat, formals)) {
+    else if (matchAttrsPat(pat, formals, ellipsis)) {
         XMLOpenElement _(doc, "attrspat");
         for (ATermIterator i(formals); i; ++i) {
             Expr name; ATerm dummy;
             if (!matchFormal(*i, name, dummy)) abort();
             doc.writeEmptyElement("attr", singletonAttrs("name", aterm2String(name)));
         }
+        if (ellipsis == eTrue) doc.writeEmptyElement("ellipsis");
     }
     else if (matchAtPat(pat, pat1, pat2)) {
         XMLOpenElement _(doc, "at");
diff --git a/src/libexpr/lexer.l b/src/libexpr/lexer.l
index b7c1d19f8a5c..81aec99e15c8 100644
--- a/src/libexpr/lexer.l
+++ b/src/libexpr/lexer.l
@@ -95,6 +95,7 @@ let         { return LET; }
 in          { return IN; }
 rec         { return REC; }
 inherit     { return INHERIT; }
+\.\.\.      { return ELLIPSIS; }
 
 \=\=        { return EQ; }
 \!\=        { return NEQ; }
diff --git a/src/libexpr/nixexpr-ast.def b/src/libexpr/nixexpr-ast.def
index 670db1976fa3..ab749b3dbe84 100644
--- a/src/libexpr/nixexpr-ast.def
+++ b/src/libexpr/nixexpr-ast.def
@@ -66,7 +66,7 @@ PrimOp | int ATermBlob ATermList | Expr |
 Attrs | ATermList | Expr |
 Closed | Expr | Expr |
 Rec | ATermList ATermList | Expr |
-Bool | ATerm | Expr |
+Bool | ATermBool | Expr |
 Null | | Expr |
 
 Bind | string Expr Pos | ATerm |
@@ -76,7 +76,7 @@ Inherit | Expr ATermList Pos | ATerm |
 Scope | | Expr |
 
 VarPat | string | Pattern |
-AttrsPat | ATermList | Pattern |
+AttrsPat | ATermList ATermBool | Pattern | # bool = `...'
 AtPat | Pattern Pattern | Pattern |
 
 Formal | string DefaultValue | ATerm |
@@ -84,8 +84,8 @@ Formal | string DefaultValue | ATerm |
 DefaultValue | Expr | DefaultValue |
 NoDefaultValue | | DefaultValue |
 
-True | | ATerm |
-False | | ATerm |
+True | | ATermBool |
+False | | ATermBool |
 
 PrimOpDef | int ATermBlob | ATerm |
 
diff --git a/src/libexpr/nixexpr.cc b/src/libexpr/nixexpr.cc
index b2d775abbcc2..d96b5be97fb9 100644
--- a/src/libexpr/nixexpr.cc
+++ b/src/libexpr/nixexpr.cc
@@ -114,12 +114,13 @@ static void varsBoundByPattern(ATermMap & map, Pattern pat)
 {
     ATerm name;
     ATermList formals;
-    Pattern pat1, pat2;    
+    Pattern pat1, pat2;
+    ATermBool ellipsis;
     /* Use makeRemoved() so that it can be used directly in
        substitute(). */
     if (matchVarPat(pat, name))
         map.set(name, makeRemoved());
-    else if (matchAttrsPat(pat, formals)) { 
+    else if (matchAttrsPat(pat, formals, ellipsis)) { 
         for (ATermIterator i(formals); i; ++i) {
             ATerm d1;
             if (!matchFormal(*i, name, d1)) abort();
diff --git a/src/libexpr/nixexpr.hh b/src/libexpr/nixexpr.hh
index 320d1dc977c5..43ac19f92a24 100644
--- a/src/libexpr/nixexpr.hh
+++ b/src/libexpr/nixexpr.hh
@@ -24,6 +24,7 @@ typedef ATerm Expr;
 typedef ATerm DefaultValue;
 typedef ATerm Pos;
 typedef ATerm Pattern;
+typedef ATerm ATermBool;
 
 
 /* A STL vector of ATerms.  Should be used with great care since it's
diff --git a/src/libexpr/parser.y b/src/libexpr/parser.y
index c48aa34aaf48..b7624df7e8aa 100644
--- a/src/libexpr/parser.y
+++ b/src/libexpr/parser.y
@@ -208,16 +208,22 @@ static void freeAndUnprotect(void * p)
 %union {
   ATerm t;
   ATermList ts;
+  struct {
+    ATermList formals;
+    bool ellipsis;
+  } formals;
 }
 
 %type <t> start expr expr_function expr_if expr_op
 %type <t> expr_app expr_select expr_simple bind inheritsrc formal
 %type <t> pattern pattern2
-%type <ts> binds ids expr_list formals string_parts ind_string_parts
+%type <ts> binds ids expr_list string_parts ind_string_parts
+%type <formals> formals
 %token <t> ID INT STR IND_STR PATH URI
 %token IF THEN ELSE ASSERT WITH LET IN REC INHERIT EQ NEQ AND OR IMPL
 %token DOLLAR_CURLY /* == ${ */
 %token IND_STRING_OPEN IND_STRING_CLOSE
+%token ELLIPSIS
 
 %nonassoc IMPL
 %left OR
@@ -326,7 +332,7 @@ pattern
 
 pattern2
   : ID { $$ = makeVarPat($1); }
-  | '{' formals '}' { $$ = makeAttrsPat($2); }
+  | '{' formals '}' { $$ = makeAttrsPat($2.formals, $2.ellipsis ? eTrue : eFalse); }
   ;
 
 binds
@@ -357,9 +363,14 @@ expr_list
   ;
 
 formals
-  : formal ',' formals { $$ = ATinsert($3, $1); } /* idem - right recursive */
-  | formal { $$ = ATinsert(ATempty, $1); }
-  | { $$ = ATempty; }
+  : formal ',' formals /* idem - right recursive */
+    { $$.formals = ATinsert($3.formals, $1); $$.ellipsis = $3.ellipsis; }
+  | formal
+    { $$.formals = ATinsert(ATempty, $1); $$.ellipsis = false; }
+  |
+    { $$.formals = ATempty; $$.ellipsis = false; }
+  | ELLIPSIS
+    { $$.formals = ATempty; $$.ellipsis = true; }
   ;
 
 formal
@@ -401,13 +412,14 @@ static void checkPatternVars(ATerm pos, ATermMap & map, Pattern pat)
     ATerm name;
     ATermList formals;
     Pattern pat1, pat2;
+    ATermBool ellipsis;
     if (matchVarPat(pat, name)) {
         if (map.get(name))
             throw EvalError(format("duplicate formal function argument `%1%' at %2%")
                 % aterm2String(name) % showPos(pos));
         map.set(name, name);
     }
-    else if (matchAttrsPat(pat, formals)) { 
+    else if (matchAttrsPat(pat, formals, ellipsis)) { 
         for (ATermIterator i(formals); i; ++i) {
             ATerm d1;
             if (!matchFormal(*i, name, d1)) abort();