[jira] Created: (BOO-903) Allow 'of' to be omitted in type references when [] are used

Allow 'of' to be omitted in type references when [] are used
------------------------------------------------------------

                 Key: BOO-903
                 URL: http://jira.codehaus.org/browse/BOO-903
             Project: Boo
          Issue Type: Improvement
    Affects Versions: 0.8
            Reporter: Rodrigo B. de Oliveira
            Assignee: Rodrigo B. de Oliveira
             Fix For: 0.8.1



I want to be able to write:

    class Maybe[T]:
        pass

    class Some[T](Maybe[T]):
        public value as T

    class None[T](Maybe[T]):
        pass

Instead of:

    class Maybe[of T]:
        pass

    class Some[of T](Maybe[of T]):
        public value as T

    class None[of T](Maybe[of T]):
        pass


All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list please visit:

    http://xircles.codehaus.org/manage_email

    [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_111511 ]

Avishay Lavie commented on BOO-903:
-----------------------------------

IMHO, this gets us farther from Booishness and closer to C#-ity. I don't have an alternative though, but the "of" makes things so much more readable and more natural.

Also:

{code}
enum Age:
  Toddler,
  Child,
  Adolescent,
  Mature,
  Elderly

class Example:
  [property(List)]
  _list as (string)

  [property(Age)]
  _age as int

  def Method():
    something = List[Age]
    # do I mean self.List[self.Age], or typeof(List[of Age])?
{code}

certainly such morbid examples are far too common to allow this to take place :)

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.1
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list please visit:

    http://xircles.codehaus.org/manage_email

    [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_122410 ]

Cedric Vivier commented on BOO-903:
-----------------------------------

I agree with Avish. It doesn't help readability and having several ways to write generic type references makes things confusing imho.

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.1
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira updated BOO-903:
---------------------------------------

    Fix Version/s:     (was: 0.8.1)
                   0.8.2

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.2
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

    [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_126911 ]

Greg Nagel commented on BOO-903:
--------------------------------

"[of X, Y Z]" still looks odd, though. Why not make it "of [X, Y, Z]"?

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.2
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira updated BOO-903:
---------------------------------------

    Fix Version/s:     (was: 0.8.2)
                   0.8.3

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.3
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

    [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=136529#action_136529 ]

Greg Nagel commented on BOO-903:
--------------------------------

Er, ignore my last comment, but should this issue be closed?

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.8.3
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira updated BOO-903:
---------------------------------------

    Fix Version/s:     (was: 0.9)
                   0.9.1

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8, 0.9
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.9.1
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira updated BOO-903:
---------------------------------------

    Fix Version/s:     (was: 0.9.1)
                   0.9.2

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8, 0.9
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.9.2
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira updated BOO-903:
---------------------------------------

    Fix Version/s:     (was: 0.9.2)
                   0.9.3

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8, 0.9
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.9.3
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

     [ http://jira.codehaus.org/browse/BOO-903?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Rodrigo B. de Oliveira closed BOO-903.
--------------------------------------

    Resolution: Won't Fix

> Allow 'of' to be omitted in type references when [] are used
> ------------------------------------------------------------
>
>                 Key: BOO-903
>                 URL: http://jira.codehaus.org/browse/BOO-903
>             Project: Boo
>          Issue Type: Improvement
>    Affects Versions: 0.8, 0.9
>            Reporter: Rodrigo B. de Oliveira
>            Assignee: Rodrigo B. de Oliveira
>             Fix For: 0.9.3
>
>
> I want to be able to write:
>     class Maybe[T]:
>         pass
>     class Some[T](Maybe[T]):
>         public value as T
>     class None[T](Maybe[T]):
>         pass
> Instead of:
>     class Maybe[of T]:
>         pass
>     class Some[of T](Maybe[of T]):
>         public value as T
>     class None[of T](Maybe[of T]):
>         pass
> All those 'of' are not necessary there for there's no ambiguity.

--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://jira.codehaus.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira

       

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email