John M. Dlugosz wrote:
How do you declare a function that returns an array?  Something like

   sub foo (blah) is Array of X { ... }

The 'is' there is your invention, isn't it? The synopsis
require 'of' or 'returns' depending if you want to specify
the outer and/or inner type. The 'is' keyword would be used as

  sub foo () is Code of Array of X {...}
  sub foo () is Code[Array[X]] {...}  # same thing

In general the of keyword instanciates parametric types just like
the direct indexing of typenames with []. The only unspecced thing
is the variance of ::Foo[::Bar] with respect to ::Bar.

seems right, but it has two problems. First is a real problem, and is a mistake seen a lot in C# and the .NET framework. A concrete type is used when it should be an interface. What if the function wants to use a List or Seq or some bizzare tied thing of its own? Defining it as

   sub foo (blah) is Positional of X { ... }

What's so bad about 'sub foo ( --> Positional of X) {...}'?

is not as snappy, and I don't think it will catch on. (I'm still wondering whether Lists and Seq's are Positional anyway, merely lazy about it)

I would thing that Seq does Positional in an immutable way.
That is in &postcircumfix:<[ ]>:(Positional $seq: Int *@@slice --> ::T)
::T is always an rvalue.

So that brings me to the second problem. For parameters, it's no problem because people just use the @ sigil and don't think about containers. So how do I do that with the return value? I don't name the return value, so there is no place to put the sigil.

  sub foo (blah) is X @*

Should be 'sub foo( --> X *@)' or 'our X *@ sub foo()'. In case that
this doesn't parse 'our :(X *@) sub foo()' should.

perhaps? I seem to recall seeing sigils in a signature without names, but now I can't remember where.

Same here. Should be in the synopsis somewhere.

Regards, TSa.

"The unavoidable price of reliability is simplicity"
  -- C.A.R. Hoare

Reply via email to