I made a function relying heavily on callbacks:
def broadth_first_search( spread : State->Array(State), finish : State->Bool, start_state : State ) : Array(State)? forall State # calculate ad return a path from start_state to a state that satisfy `finish` end
and I wrote two sub-methods to call it
# `MyState` is an existing class def spread_state(current : MyState) : Array(MyState) #... end def can_finish(current : MyState) : Bool #... end
and on calling this
bfs method, I have to add type annotation again on each proc literal:
if path = broadth_first_search( ->spread_state(State), ->can_finish(State), start ) #...
here since all needed methods have been typed and there are no conflicting overloads, can a proc literal refer to the just method, thus binding to this method needs no extra type annotations?
def plus_one(x) x+1 end add1 = ->plus_one(Int32) # ok def typed_plus_one(x : Int32) x+1 end error_add1 = ->typed_plus_one # error, but can be deduced typed_add1 = ->typed_plus_one(Int32) # ok
In the document, zero-argument method can be definitely referred because they only differ by name, so notating its name can identify its body.
def one 1 end proc_one = ->one # ok
If other method are Identical enough, can they be similarly identified?
Is the feature forbidden by design, or abandoned due to implementation complexity?