Operators and functions

General Usage
1

How come these work

==(2).(1:5)
≠(2).(1:5)
>(2).(1:5)

and these don’t ?

+(2).(1:5)
*(2).(1:5)
^(2).(1:5)
2

The syntax func.(collection) means applying func to the collection. For example

julia> (x -> 2x).(1:5)
5-element Vector{Int64}:
  2
  4
  6
  8
 10

In your example, ==(2), ≠(2) and >(2) are functions whereas +(2), *(2) and ^(2) are not.

julia> ==(2) isa Function
true

julia> +(2) isa Function
false

For more information, ==(2) is called a partial function application. This is a term from functional programming which means to fix an argument to a function. Specifically, ==(2) is equivalent to defining ==(x) = y -> x == y which is equivalent to Base.Fix2(==, 2). See the documentation of Base.Fix2 for more information about that function.

For readers who wonder why partial function applications are useful, they are mostly useful in combination with higher order functions, that is, functions which take functions such as map or filter. For example, compare

julia> map(x -> x < 2, 1:5)
5-element Vector{Bool}:
 1
 0
 0
 0
 0

julia> filter(x -> x == 2, 1:5)
1-element Vector{Int64}:
 2

julia> filter(s -> contains(s, "ar"), ["foo", "bar"])
1-element Vector{String}:
 "bar"

to

julia> map(<(2), 1:5)
5-element Vector{Bool}:
 1
 0
 0
 0
 0

julia> filter(==(2), 1:5)
1-element Vector{Int64}:
 2

julia> filter(contains("ar"), ["foo", "bar"])
1-element Vector{String}:
 "bar"
3 Likes
3

Can this notation be used to abbreviate this?

filter( x-> any( contains.(x,["a","b"]) ), ["aa","bb","cc","dd"] )

4

Not that I know of. Sounds like a nice idea though to allow applying AND and OR to functions. What does work here is to move the OR (any) inside the contains:

julia> filter(contains(r"a|b"), ["aa", "bb", "cc", "dd"])
2-element Vector{String}:
 "aa"
 "bb"
2 Likes
5

Could this functional form be available for more functions ?
2 examples

It would be nice to write this
@pipe "A=1,B=2,C=3" |> split(_,',') |> split.(_,'=')

As
"A=1,B=2,C=3" |> split(',') .|> split('=')

And it would be nice to write this

conv(x) = 
    try Date( x, dateformat"dduuuyyyy")     catch        
    try Currency_Dict[x]                    catch
    try Buy_Sell_Dict[x]                    catch
    try parse(Float64,x)                    catch    
    try Symbol(x)                           catch     
    end end end end
end

as

conv(x) = x |>
    try Date(dateformat"dduuuyyyy")     catch        
    try Currency_Dict                   catch
    try Buy_Sell_Dict                   catch
    try parse(Float64)                  catch    
    try Symbol                          catch     
    end end end end
end
6

The challenging part about this is that this is the following currently return something when the arguments are strings.

julia> split(",")
1-element Vector{SubString{String}}:
 ","

julia> split("=")
1-element Vector{SubString{String}}:
 "="

Nonetheless, you correctly identified that split(::Char) is not currently defined. Thus we could do:

julia> Base.split(c::AbstractChar) = Base.Fix2(Base.split, c)

julia> split(',')
(::Base.Fix2{typeof(split), Char}) (generic function with 1 method)

julia> "A=1,B=2,C=3" |> split(',') .|> split('=')
3-element Vector{Vector{SubString{String}}}:
 ["A", "1"]
 ["B", "2"]
 ["C", "3"]

help?> Base.Fix2
  Fix2(f, x)

  A type representing a partially-applied version of the two-argument function f, with the second argument fixed to
  the value "x". In other words, Fix2(f, x) behaves similarly to y->f(y, x).

A better definition would also allow for the other keyword arguments:

Base.split(c::AbstractChar; kwargs...) = Base.Fix2(Base.split, dlm; kwargs...)

The above could be potentially confusing, so I would prefer the following:

julia> Base.split(; dlm=isspace) = Base.Fix2(Base.split, dlm)

julia> "A=1,B=2,C=3" |> split(dlm=',') .|> split(dlm='=')
3-element Vector{Vector{SubString{String}}}:
 ["A", "1"]
 ["B", "2"]
 ["C", "3"]

The above does not allow for the other keywords. A keyword compatible version would look like this.

julia> Base.split(; dlm=isspace, kwargs...) = x->Base.split(x, dlm; kwargs...)

julia> "a b c" |> split()
3-element Vector{SubString{String}}:
 "a"
 "b"
 "c"

julia> "a b c" |> split(limit=2)
2-element Vector{SubString{String}}:
 "a"
 "b c"

Hot patching Base like this is frowned upon. It might be fine in a terminal project, but can create issues for composability. Another approach is to create your own split in a module or package and then import that into your namespace.

julia> module SplitFix2
           split(c::AbstractChar) = Base.Fix2(Base.split, c)
           split(; dlm=isspace, kwargs...) = x->Base.split(x, dlm; kwargs...)
       end
Main.SplitFix2

julia> import .SplitFix2: split

julia> "a b c" |> split(limit=2)
2-element Vector{SubString{String}}:
 "a"
 "b c"

julia> "A=1,B=2,C=3" |> split(dlm=',')
3-element Vector{SubString{String}}:
 "A=1"
 "B=2"
 "C=3"

julia> Base.split == SplitFix2.split
false

julia> @which split
Main.SplitFix2
1 Like
7

Thanks Mark.

Most functions have one argument that is the data input, and so the one I’d like to be passable from a pipe or chain. Maybe I’ll create my own versions with slightly different names (to avoid the issue you mention with split( ::string ) already being defined ).

splt(dlm)       = x -> (split(x,dlm))
fltr(f)         = x -> filter( f, x )
Dat(format)     = x -> Date( x, format)
pars(typ)       = x -> parse(typ,x)
CSV_write(file) = x -> CSV.write( file, x )
8

I like your version with split(dlm=',') as you’re able to keep the same name.