Completion by LanguageServer

[zxj5470]

• Completion startsWith NAME
• after Symbol DOT (show fields)
  • show a module's fields (names)
  • show an "object's" fields (fieldnames)

[zxj5470]

Base.in(a::AbstractString,b::AbstractString)=occursin(a,b)
using REPL
search(name::AbstractString)=REPL.doc_completions(name) |> self->filter(it -> name in it,self)

usage

julia> search("dif")
6-element Array{String,1}:
 "diff"      
 "symdiff"   
 "setdiff"   
 "symdiff!"  
 "setdiff!"  
 "Cptrdiff_t"

julia> search("diff") .|> 
           Meta.parse .|>
               eval |>
               self -> filter(it->it isa Function,self) .|>
               methods |>
               Iterators.flatten |>
               collect .|>
               self -> self.sig

18-element Array{Type,1}:
 Tuple{typeof(diff),SparseArrays.SparseMatrixCSC}                        
 Tuple{typeof(diff),AbstractArray{T,1} where T}                          
 Tuple{typeof(diff),AbstractArray{T,N}} where N where T                  
 Tuple{typeof(symdiff),Any}                                              
 Tuple{typeof(symdiff),Any,Vararg{Any,N} where N}                        
 Tuple{typeof(setdiff),AbstractSet,Vararg{Any,N} where N}                
 Tuple{typeof(setdiff),Any}                                              
 Tuple{typeof(setdiff),Any,Vararg{Any,N} where N}                        
 Tuple{typeof(symdiff!),BitSet,BitSet}                                   
 Tuple{typeof(symdiff!),AbstractArray{T,1},Vararg{Any,N} where N} where T
 Tuple{typeof(symdiff!),BitSet,Any}                                      
 Tuple{typeof(symdiff!),AbstractSet,Any}                                 
 Tuple{typeof(symdiff!),AbstractSet,Vararg{Any,N} where N}               
 Tuple{typeof(setdiff!),BitSet,BitSet}                                   
 Tuple{typeof(setdiff!),AbstractArray{T,1} where T,Vararg{Any,N} where N}
 Tuple{typeof(setdiff!),Set,Set}                                         
 Tuple{typeof(setdiff!),AbstractSet,Any}                                 
 Tuple{typeof(setdiff!),AbstractSet,Vararg{Any,N} where N}               

julia> 

[zxj5470]

using Distributed # Threads
search_module_fields(module_name::String)=names(
  module_name|>Meta.parse|>eval; all = true
)  .|> String |> self->filter!(it->!startswith(it,"#"),self) |> println

[zxj5470]

struct A
 a;b;c
end
aobject = A(1,2,3)

fieldnames(A)
fieldnames(typeof(aobject))
# or
aobject |> typeof |> fieldnames

Return

(:a, :b, :c)

julia> aobject |> typeof |> fieldnames |> collect .|> String
3-element Array{String,1}:
 "a"
 "b"
 "c"

[zxj5470]

get return type

Base.return_types(occursin)
6-element Array{Any,1}:
 Bool                                      
 Bool                                      
 Union{Missing, Bool, ##58#59{_1} where _1}
 Bool                                      
 Bool                                      
 Union{Missing, Bool}                      

Specify param

Base.return_types(occursin,(Regex,SubString))
1-element Array{Any,1}:
 Bool