Change the last two args of split/rsplit to 'limit' and 'keep' keywor…

…ds. Fixes JuliaLang#6412

base/client.jl

@@ -236,7 +236,7 @@ function process_options(args::Vector{UTF8String})
  addprocs(np)
  elseif args[i]=="--machinefile"
  i+=1
- machines = split(readall(args[i]), '\n', false)
+ machines = split(readall(args[i]), '\n'; keep=false)
  addprocs(machines)
  elseif args[i]=="-v" || args[i]=="--version"
  println("julia version ", VERSION)

base/deprecated.jl

@@ -141,6 +141,10 @@ Set{T<:Number}(xs::T...) = Set{T}(xs)
 @deprecate readsfrom(cmd, args...) open(cmd, "r", args...)
 @deprecate writesto(cmd, args...) open(cmd, "w", args...)
 
+@deprecate split(x,y,l::Integer,k::Bool) split(x,y;limit=l,keep=k)
+@deprecate split(x,y,l::Integer) split(x,y;limit=l)
+@deprecate split(x,y,k::Bool) split(x,y;keep=k)
+
 function tty_rows()
  depwarn("tty_rows() is deprecated, use tty_size() instead", :tty_rows)
  tty_size()[1]

base/pkg/github.jl

@@ -34,7 +34,7 @@ function curl(url::String, opts::Cmd=``)
  success(`curl --version`) || error("using the GitHub API requires having `curl` installed")
  out, proc = open(`curl -i -s -S $opts $url`,"r")
  head = readline(out)
- status = int(split(head,r"\s+",3)[2])
+ status = int(split(head,r"\s+";limit=3)[2])
  for line in eachline(out)
  ismatch(r"^\s*$",line) || continue
  wait(proc); return status, readall(out)

base/precompile.jl

@@ -94,8 +94,8 @@ precompile(effect_free, (TopNode,))
 precompile(abspath, (ASCIIString,))
 precompile(isabspath, (ASCIIString,))
 precompile(split, (ASCIIString,))
-precompile(split, (ASCIIString, ASCIIString, Int, Bool))
-precompile(split, (ASCIIString, Regex, Int, Bool))
+precompile(split, (ASCIIString, ASCIIString))
+precompile(split, (ASCIIString, Regex))
 precompile(print_joined, (IOBuffer, Array{String,1}, ASCIIString))
 precompile(beginswith, (ASCIIString, ASCIIString))
 precompile(resolve_globals, (Symbol, Module, Module, Vector{Any}, Vector{Any}))

base/string.jl

@@ -1032,7 +1032,7 @@ function triplequoted(args...)
  sx = { isa(arg,ByteString) ? arg : esc(arg) for arg in args }
 
  indent = 0
- rlines = split(RevString(sx[end]), '\n', 2)
+ rlines = split(RevString(sx[end]), '\n'; limit=2)
  last_line = rlines[1]
  if length(rlines) > 1 && lstrip(last_line) == ""
  indent,_ = indentation(last_line)
@@ -1287,8 +1287,8 @@ cpad(s, n::Integer, p=" ") = rpad(lpad(s,div(n+strwidth(s),2),p),n,p)
 
 # splitter can be a Char, Vector{Char}, String, Regex, ...
 # any splitter that provides search(s::String, splitter)
-split{T<:SubString}(str::T, splitter, limit::Integer, keep_empty::Bool) = _split(str, splitter, limit, keep_empty, T[])
-split{T<:String}(str::T, splitter, limit::Integer, keep_empty::Bool) = _split(str, splitter, limit, keep_empty, SubString{T}[])
+split{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, T[])
+split{T<:String}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, SubString{T}[])
 function _split{T<:String,U<:Array}(str::T, splitter, limit::Integer, keep_empty::Bool, strs::U)
  i = start(str)
  n = endof(str)
@@ -1310,17 +1310,13 @@ function _split{T<:String,U<:Array}(str::T, splitter, limit::Integer, keep_empty
  end
  return strs
 end
-split(s::String, spl, n::Integer) = split(s, spl, n, true)
-split(s::String, spl, keep::Bool) = split(s, spl, 0, keep)
-split(s::String, spl) = split(s, spl, 0, true)
 
 # a bit oddball, but standard behavior in Perl, Ruby & Python:
 const _default_delims = [' ','\t','\n','\v','\f','\r']
-split(str::String)  = split(str, _default_delims, 0, false)
+split(str::String) = split(str, _default_delims; limit=0, keep=false)
 
-
-rsplit{T<:SubString}(str::T, splitter, limit::Integer, keep_empty::Bool) = _rsplit(str, splitter, limit, keep_empty, T[])
-rsplit{T<:String}(str::T, splitter, limit::Integer, keep_empty::Bool) = _rsplit(str, splitter, limit, keep_empty, SubString{T}[])
+rsplit{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, T[])
+rsplit{T<:String}(str::T, splitter ; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, SubString{T}[])
 function _rsplit{T<:String,U<:Array}(str::T, splitter, limit::Integer, keep_empty::Bool, strs::U)
  i = start(str)
  n = endof(str)
@@ -1340,9 +1336,6 @@ function _rsplit{T<:String,U<:Array}(str::T, splitter, limit::Integer, keep_empt
  (keep_empty || (n > 0)) && unshift!(strs, SubString(str,1,n))
  return strs
 end
-rsplit(s::String, spl, n::Integer) = rsplit(s, spl, n, true)
-rsplit(s::String, spl, keep::Bool) = rsplit(s, spl, 0, keep)
-rsplit(s::String, spl) = rsplit(s, spl, 0, true)
 #rsplit(str::String) = rsplit(str, _default_delims, 0, false)
 
 function replace(str::ByteString, pattern, repl::Function, limit::Integer)

doc/stdlib/base.rst

@@ -1290,11 +1290,11 @@ Strings
 
  Search for the given pattern ``pat``, and replace each occurrence with ``r``. If ``n`` is provided, replace at most ``n`` occurrences. As with search, the second argument may be a single character, a vector or a set of characters, a string, or a regular expression. If ``r`` is a function, each occurrence is replaced with ``r(s)`` where ``s`` is the matched substring.
 
-.. function:: split(string, [chars, [limit,] [include_empty]])
+.. function:: split(string, [chars, [limit=0,] [keep=true]])
 
  Return an array of substrings by splitting the given string on occurrences of the given character delimiters, which may be specified in any of the formats allowed by ``search``'s second argument (i.e. a single character, collection of characters, string, or regular expression). If ``chars`` is omitted, it defaults to the set of all space characters, and ``include_empty`` is taken to be false. The last two arguments are also optional: they are are a maximum size for the result and a flag determining whether empty fields should be included in the result.
 
-.. function:: rsplit(string, [chars, [limit,] [include_empty]])
+.. function:: rsplit(string, chars, [limit=0, [keep=true]])
 
  Similar to ``split``, but starting from the end of the string.
 

test/strings.jl

@@ -497,58 +497,58 @@ end
 @test isequal(split("foo,bar,baz", ','), ["foo","bar","baz"])
 @test isequal(split("foo,bar,baz", ","), ["foo","bar","baz"])
 @test isequal(split("foo,bar,baz", r","), ["foo","bar","baz"])
-@test isequal(split("foo,bar,baz", ',', 0), ["foo","bar","baz"])
-@test isequal(split("foo,bar,baz", ',', 1), ["foo,bar,baz"])
-@test isequal(split("foo,bar,baz", ',', 2), ["foo","bar,baz"])
-@test isequal(split("foo,bar,baz", ',', 3), ["foo","bar","baz"])
+@test isequal(split("foo,bar,baz", ','; limit=0), ["foo","bar","baz"])
+@test isequal(split("foo,bar,baz", ','; limit=1), ["foo,bar,baz"])
+@test isequal(split("foo,bar,baz", ','; limit=2), ["foo","bar,baz"])
+@test isequal(split("foo,bar,baz", ','; limit=3), ["foo","bar","baz"])
 @test isequal(split("foo,bar", "o,b"), ["fo","ar"])
 
 @test isequal(split("", ','), [""])
 @test isequal(split(",", ','), ["",""])
 @test isequal(split(",,", ','), ["","",""])
-@test isequal(split("", ',', false), [])
-@test isequal(split(",", ',', false), [])
-@test isequal(split(",,", ',', false), [])
+@test isequal(split("", ',' ; keep=false), [])
+@test isequal(split(",", ',' ; keep=false), [])
+@test isequal(split(",,", ','; keep=false), [])
 
 @test isequal(split("a b c"), ["a","b","c"])
 @test isequal(split("a b \t c\n"), ["a","b","c"])
 
 @test isequal(rsplit("foo,bar,baz", 'x'), ["foo,bar,baz"])
 @test isequal(rsplit("foo,bar,baz", ','), ["foo","bar","baz"])
 @test isequal(rsplit("foo,bar,baz", ","), ["foo","bar","baz"])
-@test isequal(rsplit("foo,bar,baz", ',', 0), ["foo","bar","baz"])
-@test isequal(rsplit("foo,bar,baz", ',', 1), ["foo,bar,baz"])
-@test isequal(rsplit("foo,bar,baz", ',', 2), ["foo,bar","baz"])
-@test isequal(rsplit("foo,bar,baz", ',', 3), ["foo","bar","baz"])
+@test isequal(rsplit("foo,bar,baz", ','; limit=0), ["foo","bar","baz"])
+@test isequal(rsplit("foo,bar,baz", ','; limit=1), ["foo,bar,baz"])
+@test isequal(rsplit("foo,bar,baz", ','; limit=2), ["foo,bar","baz"])
+@test isequal(rsplit("foo,bar,baz", ','; limit=3), ["foo","bar","baz"])
 @test isequal(rsplit("foo,bar", "o,b"), ["fo","ar"])
 
 @test isequal(rsplit("", ','), [""])
 @test isequal(rsplit(",", ','), ["",""])
 @test isequal(rsplit(",,", ','), ["","",""])
-@test isequal(rsplit(",,", ',', 2), [",",""])
-@test isequal(rsplit("", ',', false), [])
-@test isequal(rsplit(",", ',', false), [])
-@test isequal(rsplit(",,", ',', false), [])
+@test isequal(rsplit(",,", ','; limit=2), [",",""])
+@test isequal(rsplit("", ',' ; keep=false), [])
+@test isequal(rsplit(",", ',' ; keep=false), [])
+@test isequal(rsplit(",,", ','; keep=false), [])
 
 #@test isequal(rsplit("a b c"), ["a","b","c"])
 #@test isequal(rsplit("a b \t c\n"), ["a","b","c"])
 
 let str = "a.:.ba..:..cba.:.:.dcba.:."
 @test isequal(split(str, ".:."), ["a","ba.",".cba",":.dcba",""])
-@test isequal(split(str, ".:.", false), ["a","ba.",".cba",":.dcba"])
+@test isequal(split(str, ".:."; keep=false), ["a","ba.",".cba",":.dcba"])
 @test isequal(split(str, ".:."), ["a","ba.",".cba",":.dcba",""])
 @test isequal(split(str, r"\.(:\.)+"), ["a","ba.",".cba","dcba",""])
-@test isequal(split(str, r"\.(:\.)+", false), ["a","ba.",".cba","dcba"])
+@test isequal(split(str, r"\.(:\.)+"; keep=false), ["a","ba.",".cba","dcba"])
 @test isequal(split(str, r"\.+:\.+"), ["a","ba","cba",":.dcba",""])
-@test isequal(split(str, r"\.+:\.+", false), ["a","ba","cba",":.dcba"])
+@test isequal(split(str, r"\.+:\.+"; keep=false), ["a","ba","cba",":.dcba"])
 
 @test isequal(rsplit(str, ".:."), ["a","ba.",".cba.:","dcba",""])
-@test isequal(rsplit(str, ".:.", false), ["a","ba.",".cba.:","dcba"])
-@test isequal(rsplit(str, ".:.", 2), ["a.:.ba..:..cba.:.:.dcba", ""])
-@test isequal(rsplit(str, ".:.", 3), ["a.:.ba..:..cba.:", "dcba", ""])
-@test isequal(rsplit(str, ".:.", 4), ["a.:.ba.", ".cba.:", "dcba", ""])
-@test isequal(rsplit(str, ".:.", 5), ["a", "ba.", ".cba.:", "dcba", ""])
-@test isequal(rsplit(str, ".:.", 6), ["a", "ba.", ".cba.:", "dcba", ""])
+@test isequal(rsplit(str, ".:."; keep=false), ["a","ba.",".cba.:","dcba"])
+@test isequal(rsplit(str, ".:."; limit=2), ["a.:.ba..:..cba.:.:.dcba", ""])
+@test isequal(rsplit(str, ".:."; limit=3), ["a.:.ba..:..cba.:", "dcba", ""])
+@test isequal(rsplit(str, ".:."; limit=4), ["a.:.ba.", ".cba.:", "dcba", ""])
+@test isequal(rsplit(str, ".:."; limit=5), ["a", "ba.", ".cba.:", "dcba", ""])
+@test isequal(rsplit(str, ".:."; limit=6), ["a", "ba.", ".cba.:", "dcba", ""])
 end
 
 # zero-width splits