Add Channel{T}(f::Function) constructors.

The Channel constructors that do and don't create a Task are currently
written in different styles:

 - The non-Task constructor takes a Type {T} as a type parameter, and
 the size as a positional argument.
    - `Channel{Int}(Inf)`
    - `Channel(0)`

 - The Task constructor takes a Function, but the size and type are
keyword arguments:
    - `Channel(c->put!(c,0), ctype=Int, csize=0)`
    - `Channel(ctype=Int, csize=0, taskref=t) do c; put!(c,0); end`

This commit adds convenience methods to the Task-creating constructor,
allowing you to specify the Type and/or size as in the non-Task
constructor:
    - `Channel{Char}(1) do c; put!(c, 'a'); end`
    - `Channel{Char}(csize=2, taskref=t) do c; put!(c, 'a'); end`

---

Also adds tests for the existing Task-creating constructors, which
weren't explicitly tested before.

Author: NHDaly

base/channels.jl

@@ -95,6 +95,22 @@ Hello
 julia> istaskdone(taskref[])
 true
 ```
+
+Other constructors:
+* `Channel{T}(func::Function, sz=0)`
+* `Channel{T}(func::Function; csize=0, taskref=nothing)`
+
+```jldoctest
+julia> chnl = Channel{Char}(1) do ch
+           for c in "hello world"
+               put!(ch, c)
+           end
+       end
+>> Channel{Char}(sz_max:1,sz_curr:1)
+
+julia> String(collect(chnl))
+>> "hello world"
+```
 """
 function Channel(func::Function; ctype=Any, csize=0, taskref=nothing)
     chnl = Channel{ctype}(csize)
@@ -105,6 +121,12 @@ function Channel(func::Function; ctype=Any, csize=0, taskref=nothing)
     isa(taskref, Ref{Task}) && (taskref[] = task)
     return chnl
 end
+function Channel{T}(f::Function, sz=0) where T
+    return Channel(f, csize=sz, ctype=T)
+end
+function Channel{T}(f::Function; csize=0, taskref=nothing) where T
+    return Channel(f, csize=csize, ctype=T, taskref=taskref)
+end
 
 
 closed_exception() = InvalidStateException("Channel is closed.", :closed)

test/channels.jl

@@ -36,6 +36,32 @@ end
     @test_throws InexactError Channel(1.5)
 end
 
+@testset "Task constructors" begin
+    c = Channel(ctype=Float32, csize=2) do c; map(i->put!(c,i), 1:100); end
+    @test eltype(c) == Float32
+    @test c.sz_max == 2
+    @test isopen(c)
+    @test collect(c) == 1:100
+
+    c = Channel{Int}() do c; map(i->put!(c,i), 1:100); end
+    @test eltype(c) == Int
+    @test c.sz_max == 0
+    @test collect(c) == 1:100
+
+    c = Channel{Int}(Inf) do c; put!(c,1); end
+    @test eltype(c) == Int
+    @test c.sz_max == typemax(Int)
+
+    taskref = Ref{Task}()
+    c = Channel{Int}(csize=0, taskref=taskref) do c; put!(c, 0); end
+    @test eltype(c) == Int
+    @test c.sz_max == 0
+    @test istaskstarted(taskref[])
+    @test !istaskdone(taskref[])
+    take!(c); yield()
+    @test istaskdone(taskref[])
+end
+
 @testset "multiple concurrent put!/take! on a channel for different sizes" begin
     function testcpt(sz)
         c = Channel{Int}(sz)