FileSetCE.fs

type FileSetBuilder() =
    member x.Delay f = f
    member x.Run f = f() |> Scan
    member x.Yield (()) = { Include "" with Includes = [] }
    
    [<CustomOperation ("take", MaintainsVariableSpace = true)>]
    member x.Take (fs, pattern: string) = fs ++ pattern

    [<CustomOperation ("notTake", MaintainsVariableSpace = true)>]
    member x.NotTake (fs: FileIncludes, pattern: string) = fs -- pattern

let files = FileSetBuilder()

Target "Build" {
    files { 
        take "**\bin\**\*Tests.dll"
        take "**\bin2\**\*Tests.dll"
        take "**\binaries\**\*"
        notTake "**\bin2\Special*\*"
        take "**\binaries2\**\*"
    }
    |> MSBuildDebug @".\out1" "Build"
    |> Log "AppBuild-Output: " 
}

// old syntax
Target "Build" <| fun _ ->
    !+ "**\bin\**\*Tests.dll"
    ++ "**\bin2\**\*Tests.dll"
    ++ "**\binaries\**\*"
    -- "**\bin2\Special*\*"
    ++ "**\binaries2\**\*"
    |> Scan
    |> MSBuildDebug @".\out1" "Build"
    |> Log "AppBuild-Output: " 

Actually I don't think it's that big problem. Usually we only have !! and one pattern sometimes one additional ++ or --

Love that CE syntax, much nicer than the operators which I never remember which is what.

How about something in the direction of:

Scan [
  "**\bin\**\*Tests.dll"
  "**\bin2\**\*Tests.dll"
  "**\binaries\**\*"
  "**\binaries2\**\*]
|> Exlude  "**\bin2\Special*\*"
|> MSBuild ...

or even

Scan "**\bin\**\*Tests.dll"
|> Include "**\bin2\**\*Tests.dll"
|> Include "**\binaries\**\*"
|> Include "**\binaries2\**\*
|> Exlude  "**\bin2\Special*\*"
|> MSBuild ... 

BTW: Did you see fsprojects/FAKE@5def167

The original "Scan" is not needed anymore. Filesets implement IEnumerable.
Therefor !! is the same as !+

I think the ++ and -- are ok for operators, as it's easy to associate them to include and exclude, but I really don't like !!, as it's very non-obvious. Any of the non-operator alternatives is fine

/// Include files
let Include x =    
    { BaseDirectories = [DefaultBaseDir];
      Includes = [x];
      Excludes = []}       

/// Includes a single pattern and scans the files
let inline (!!) x = Include x

It's already there....

How about we add this:

let Exclude y x  = x -- y

let AndInclude y x  = x ++ y

the you could write:

Include"**\bin\**\*Tests.dll"
|> AndInclude "**\bin2\**\*Tests.dll"
|> AndInclude "**\binaries\**\*"
|> AndInclude "**\binaries2\**\*
|> Exlude  "**\bin2\Special*\*"
|> MSBuild ... 

I think for normal F# code all the approaches are perfectly OK. !!, ++ and -- are even then best (I like operators :) )
But I remember how much confused was a tester from my team as he saw them for the first time.
So, I think we should not use cryptic unusual symbols at all. Your Include...AndInclude...Exclude are better but the piping operator is basically as weird as !! ++ -- for a non-F#-er.
However, if a build script is created and maintained by a F# dev(s) it's even more preferable to use the operators. But for the rest of the world we should offer a more 'normal' alternative.
So, I suggest to support all three ways: operators, function composition via |> and >> and CEs (I even wrote one for the NUnit task and it looks ok ;)

On could also add methods to the FileSet object and do it C# fluent style.

Like

Include("**\bin\**\*Tests.dll")
  .And("**\bin2\**\*Tests.dll")
  .And("**\binaries\**\*")
  .And("**\binaries2\**\*)
  .ButNot("**\bin2\Special*\*")

I for one would have the least surprise when obvious names are used with the builtin function composition options (like pipe operator). I feel quite safe with the scan/include/exclude syntax. It's nice to have a more 'obvious' syntax for the beginner as well as a more 'terse' syntax for the advanced users.

I'm rather sceptical about C# fluent style these days. However, as an option among others it could be ideal for using by C# devs.