lang.scala (date)

[David Pollak <dpp@xxxxxxxxxx>]

Let me second Jamie's suggestion of being able to create intermediate  
values that could be used later in the same scope.  For example  
(using Jamie's code):


> val myWindow = new Window {
>       title = "My Title"
>       content = VBox(
>           val myLabel = new Label {
>               text = "A"
>           },
>           new Button {
>               text = "Click Me"
>               onClick = { event =>
>                   myLabel.text = "B"
>               }
>           }
>       )

It's kind of like for (int x = 0; x < 10; x++)...

I'm also a huge fan of Ruby's hash constructor {:foo => "bar", :baz  
=> "dog"}  Having a similar (new-free) way of creating Maps would be  
cool.  Especially if the map constructor would default to an  
immutable map.  If you wanted another map class, you would specify it  
like {:HashMap "foo" -> "bar", "baz" -> "dog"}

On the list front, the existing List creator works really well for me.

Finally, it would be most excellent to have traits for immutable sets  
and hashes such that the traits were implemented (sorry, Java-speak)  
on both mutable and immutable sets (as well as lists) and hashes.

On a separate note, I looked at the implementation of immutable  
ListMap and it looks like lookup time is O(n) rather than O(~1) for  
HashMap.  Is this correct?  If so, is there any way to make the  
immutable ListMaps more efficient for lookup?

On a separate, separate note, is there any information carried around  
with functions/methods that indicate if the have side effects such  
that the value of functions/methods that have no side effects can be  
cached and possibly marking a function/method that takes a function  
as a parameter as requiring a side-effect-free function.  I'm kinda  
thinking about the 'const' declaration in C++.

On a separate, separate, separate note (okay, this is becoming a wish- 
list), I really, really like Ruby's "if at the end of the line"  
construct:
return foo if bar
return baz if dog

Any chance of a similar construct in Scala or does it just start  
messing up what is very clean syntax?

Sorry about my rambling.

Happy New Year to all that observe the Julian Calendar and have a  
very, very excellent next 365 days to everyone else!

Thanks,

David

On Dec 31, 2006, at 8:04 AM, Jamie Webb wrote:

> On Sun, Dec 31, 2006 at 07:59:04AM +0000, Andy Dwelly wrote:
> > Panel p = new Panel(new FlowLayout());
> > JButton b = new JButton("Press me!");
> > b.setEventListener(somethingOrOther);
> > p.add(b);
> > JSomething foo = new JSomething(blah, blah);
> > foo.setAttribute();
> > foo.setOtherAttribute();
> > foo.soGladIDontDoThisKindOfThingAnymore();
> > p.add(foo);
> >
> > of course solving this needs more than just literals for maps.
>
> Yes, it's possible to come up with much more elegant ways to write
> stuff like that in Scala. IMO the biggest limitation is that there's
> no nice way to refer to declaratively constructed objects that are
> deeply nested. Consider:
>
>   var myLabel = null
>   val myWindow = new Window {
>       title = "My Title"
>       content = VBox(
>           new Label {
>               text = "A"
>               myLabel = this
>           },
>           new Button {
>               text = "Click Me"
>               onClick = { event =>
>                   myLabel.text = "B"
>               }
>           }
>       )
>   }
>
> It's all pretty neat and should be a good way to do things in Scala,
> apart from the horrible hack I used to get hold of a reference to the
> Label object. Of course I could have just constructed the label on
> that first line instead, but then I'd be heading back in the direction
> of the unstructured Java code.
>
> /J

--
David Pollak
http://blog.lostlake.org