Re: dynamically creating instances

So can Maker now be used with something other than a String? Do you have 
an example?

This is really fascinating, but I need to get much more familiar with 
the type system before it really makes sense to me.

Thanks!

Chas.

David Pollak wrote:
> import scala.reflect.Manifest
> 
> object Maker {
>   def apply[T](params: Any*)(implicit m: Manifest[T]): T = {
>     val p2: Seq[Object] = params.flatMap {
>       case o: Object => Some(o)
>       case _ => None
>     }
> 
>     val paramClasses: Seq[Class[_]] = p2.map(_.getClass)
> 
>     m.erasure.getConstructor(paramClasses :_*).
>     newInstance(p2 :_*).asInstanceOf[T]
>   }
> 
>   def apply(clz: String, params: Any*): AnyRef = {
>     val p2: Seq[Object] = params.flatMap {
>       case o: Object => Some(o)
>       case _ => None

Re: How to use synchronized?

Re: dynamically creating instances

Are you familar with how lift creates fetched entities? See MetaMapper.createOne IIRC.

-------------------------------------
Charles F. Munat<chas@...> wrote:

So can Maker now be used with something other than a String? Do you have 
an example?

This is really fascinating, but I need to get much more familiar with 
the type system before it really makes sense to me.

Thanks!

Chas.

David Pollak wrote:
> import scala.reflect.Manifest
> 
> object Maker {
>   def apply[T](params: Any*)(implicit m: Manifest[T]): T = {
>     val p2: Seq[Object] = params.flatMap {
>       case o: Object => Some(o)
>       case _ => None
>     }
> 
>     val paramClasses: Seq[Class[_]] = p2.map(_.getClass)
> 
>     m.erasure.getConstructor(paramClasses :_*).
>     newInstance(p2 :_*).asInstanceOf[T]
>   }
> 
>   def apply(clz: String, params: Any*): AnyRef = {
>     val p2: Seq[Object] = params.flatMap {
>       case o: Object => Some(o)
>       case _ => None
>     }
> 
>     val paramClasses: Seq[Class[_]] = p2.map(_.getClass)
> 
>     Class.forName(clz).getConstructor(paramClasses :_*).
>     newInstance(p2 :_*).asInstanceOf[AnyRef]
>   }
> }
> 
> println(Maker[String](Array('c','a', 't')))
> 
> println(Maker("java.lang.String", Array('d','o', 'g')))
> 
> 
> 
> On Mon, Aug 31, 2009 at 12:58 PM, Charles F. Munat <chas@... 
> <mailto:chas@...>> wrote:
> 
>     Meta model class hierarchy? (I love responses that use the word
>     "just" 
> 
>     Chas.
> 
> 
>     John Nilsson wrote:
> 
>         On Mon, Aug 31, 2009 at 7:05 PM, Erik
>         Engbrecht<erik.engbrecht@...
>         <mailto:erik.engbrecht@...>> wrote:
> 
>             I've been giving use cases like this some thought and I'd
>             like to toss some
>             ideas out for the community...
> 
>             In the simple case, I want to be able to write a generic
>             function (in
>             psuedo-scala):
>              (Class[T], Map[String, Sting]) => T
> 
> 
>         I fail to see what this would be good for.
>         Either you are going to write all those constructors and classes by
>         hand. In which case adding the additional code to map input to these
>         classes wouldn't be that hard.
> 
>         Or you really need dynamic objects, in which case there is no reason
>         to imagine a T just design a meta model class hierarchy.
> 
>         BR,
>         John
> 
> 
> 
> 
> 
> -- 
> Lift, the simply functional web framework http://liftweb.net
> Beginning Scala http://www.apress.com/book/view/1430219890
> Follow me: http://twitter.com/dpp
> Git some: http://github.com/dpp

Re: How to use synchronized?

Hi Jorge,

Scala has a number of these conceptual constructs that get compiled
specially, and they are documented specially in the Scaladoc. I'd call
this a bug in that special treatment of synchronized in whatever
program generates Scaladoc for the Scala API. Conceptually,
synchronized is a method that takes a by-name parameter, so it should
really show up that way in the API docs for Scala.

Bill

On Mon, Aug 31, 2009 at 4:34 PM, Jorge Ortiz<jorge.ortiz@...> wrote:
> Scala's synchronized is a "method" in that for all intents and purposes it
> looks and acts like a method, but it is special in that the sense that it
> exists as a special form in Java, and gets compiled down to the special form
> rather than a method call. A type signature of synchronized[T0](arg0: =>
> T0): T0 would probably be less misleading, but the point is kind of moot as
> it's probably just getting translated to Java's synchronized(this) { ... }.
>
> --j
>
> On Mon, Aug 31, 2009 at 1:00 PM, Rodrigo Cano <ioniviil@...> wrote:
>>
>> Yes, I perfectly understand what synchronized is for, I had worked a lot
>> with threads in java, and know how to use it, thank you. What puzzles me is
>> that the signature for it according to the scaladoc is
>> final def synchronized[T0](arg0 : T0) : T0 So, what is T0, it doesnt look
>> like a by-name paremeter. That is why I wrote a function with similar
>> arguments (the debug function I showed you), and see that the code didn't
>> got executed within debug.
>> Happily, I already understood by-name parameters and functions in scala,
>> so that is not the problem. Thanks for the explanation anyway, but my doubt
>> still remains. What is T0, is it a function?, a by-name?, there is no
>> sourcecode for Any, so I cannot see for myself.
>>
>> Anyway, according to the examples you showed me about how to use it, I
>> suppose that it must be a by-name parameter, and it gets executed
>> synchronizedly returning after that, as in the "val x = 2 * synchronized"
>> that Naftoli Gugenheim kindly showed me.
>>
>> Thanks.
>> Rodrigo
>>
>>
>> On Mon, Aug 31, 2009 at 3:48 PM, David Flemström
>> <david.flemstrom@...> wrote:
>>>
>>> synchronized is useful when you're dealing with threading; you basically
>>> want to make sure that a method (or section of code) is called only once at
>>> any point in time, so that two threads don't try to access the method
>>> simultaneously and thereby disrupt some kind of state that the method
>>> maintains.
>>>
>>> So for example if I write:
>>>
>>> import scala.actors.Actor._
>>> def a() = {
>>> val someInt = Random.nextInt(10) //random number between 0 and 10
>>> for(i <- 0 to 2000)
>>> println("hello " + someInt) //prints 2000 times
>>> }
>>>
>>> actor {
>>> a()
>>> }
>>> actor {
>>> a()
>>> }
>>>
>>> ...then a will be called simultaneously (probably) by two threads. You
>>> might then get output like this:
>>> hello 3
>>> hello 3
>>> hello 2
>>> hello 3
>>> hello 2
>>> hello 3
>>> hello 2
>>> hello 3
>>> hello 2
>>> ...continues mixed like this exactly 4000 times
>>>
>>> However, if we set a to be synchronized, it can only be "visited" by one
>>> thread at once, so:
>>> def a() = synchronized {
>>> //...
>>> }
>>>
>>> will make the output look like this:
>>> hello 9
>>> hello 9
>>> hello 9
>>> hello 9
>>> ...continues exactly 2000 times
>>> hello 4
>>> hello 4
>>> hello 4
>>> hello 4
>>> hello 4
>>> hello 4
>>> ...continues exactly 2000 times
>>>
>>> synchronized can be very useful in methods that change some shared
>>> variables, or needs to perform operations that cannot be interrupted by
>>> other threads.
>>>
>>> On Monday 31 August 2009 20:34:56 Rodrigo Cano wrote:
>>> > Exactly that, how to use the synchronized method that all objects
>>> > inherit?
>>> > I cannot understand from its signature. The method accepts just
>>> > anything?
>>> > and returns it!?
>>> >
>>> > I tried a method test method with a similar signature to find out
>>> >
>>> > def debug[T0](arg0: T0): T0 = {
>>> > println("Arg is " + arg0.asInstanceOf[AnyRef].getClass)
>>> > arg0
>>> > }
>>> >
>>> > And tried calling it as:
>>> >
>>> > debug {
>>> > println("What im doing?")
>>> > }
>>> >
>>> > But the println("Waht im doing?") prints first, and the getClass
>>> > returns
>>> > BoxedUnit. So no idea of how synchronized actually works
>>> >
>>> > Thanks.
>>> > Rodrigo
>>>
>>> David Flemström
>>> david.flemstrom@...
>
>

--

-- 
Bill Venners
Artima, Inc.
http://www.artima.com

Re: How to use synchronized?

Rodrigo Cano wrote:
> 
> Yes, I perfectly understand what synchronized is for, I had worked a lot
> with threads in java, and know how to use it, thank you. 
> 

Well, no, evidently not.  

"synchronized" in Scala is purely more powerful that "synchronized" in Java. 
The T0 is a type parameter, not a by-name parameter.  It means that the
"synchronized" method in Scala can evaluate to a value (unlike the
"synchronized" statement in Java).  The value returned by the synchronized
method is whatever is returned by the argument to the synchronized method.  
In your case, that return is of type "Unit" (similar to "void" in Java)
since that's the type that the last expression in your synchronized
statement's argument has.   Most of the time, you don't have to explicitly
specify T0, since Scala's type inference will do that for you.  

Also, this would be a good place to say that you really don't want to mix
actor semantics with low-level thread-wrangling semantics like
"synchronized" (or "wait", or "notify").  Do that naively, and the best you
can hope for is an ugly deadlock.  After that things get more difficult to
diagnose.

In general, anything you see in Scala that looks similar to something in
Java will be just similar enough to tweak your intuition, but not similar
enough for you to actually understand it fully.  

--Dave Griffith

--

-- 
View this message in context: http://www.nabble.com/How-to-use-synchronized--tp25228291p25232855.html
Sent from the Scala - User mailing list archive at Nabble.com.

Re: How to use synchronized?

Hi Dave,

I think arg0 is what we're saying should be a by-name parameter, not
T0. Instead of:

def synchronized[T0](arg0: T0): T0 = arg0

it should probably be:

def synchronized[T0](arg0: => T0): T0 = arg0

Because if it isn't a by-name, how could this conceptual synchronized
method actually acquire the lock before executing the code that needs
to be synchronized.

Bill

On Mon, Aug 31, 2009 at 6:07 PM, Dave
Griffith<dave.l.griffith@...> wrote:
>
>
>
> Rodrigo Cano wrote:
>>
>> Yes, I perfectly understand what synchronized is for, I had worked a lot
>> with threads in java, and know how to use it, thank you.
>>
>
> Well, no, evidently not.
>
> "synchronized" in Scala is purely more powerful that "synchronized" in Java.
> The T0 is a type parameter, not a by-name parameter.  It means that the
> "synchronized" method in Scala can evaluate to a value (unlike the
> "synchronized" statement in Java).  The value returned by the synchronized
> method is whatever is returned by the argument to the synchronized method.
> In your case, that return is of type "Unit" (similar to "void" in Java)
> since that's the type that the last expression in your synchronized
> statement's argument has.   Most of the time, you don't have to explicitly
> specify T0, since Scala's type inference will do that for you.
>
> Also, this would be a good place to say that you really don't want to mix
> actor semantics with low-level thread-wrangling semantics like
> "synchronized" (or "wait", or "notify").  Do that naively, and the best you
> can hope for is an ugly deadlock.  After that things get more difficult to
> diagnose.
>
> In general, anything you see in Scala that looks similar to something in
> Java will be just similar enough to tweak your intuition, but not similar
> enough for you to actually understand it fully.
>
> --Dave Griffith
>
> --
> View this message in context: http://www.nabble.com/How-to-use-synchronized--tp25228291p25232855.html
> Sent from the Scala - User mailing list archive at Nabble.com.
>
>

--

-- 
Bill Venners
Artima, Inc.
http://www.artima.com

Re: Type promotion for binary operators?

Re: How to use synchronized?

Scala/Hadoop function override question

Re: How to use synchronized?