http://permalink.gmane.org/gmane.comp.lang.scala.user hourly 1 1901-01-01T00:00+00:00 http://gmane.org/img/gmane-25t.png http://gmane.org http://permalink.gmane.org/gmane.comp.lang.scala.user/63389 <pre>Hi. I am developing an integration with Activate (http://activate-framework.org/). I've tested the postgresql driver and it works very well! I am anxious to see what are the performance and scalability characteristcs of the driver. </pre> Flavio W. Brasil 2013-05-18T21:51:43 http://permalink.gmane.org/gmane.comp.lang.scala.user/63388 <pre>I wonder how much of a game-changer. Both mysql and postgres both still have connection limits... MySQL I know *can* get in to the 10K simultaneous connections range, but it requires a pretty beefed-up machine. The default is 150 IIRC. Still... hooking asynch DB access up with Akka... I bet you could get some pretty ridiculously good throughput compared to more traditional webapp architecture for a given piece of hardware. On Sat, May 18, 2013 at 1:26 PM, virtualeyes &lt;sit1way-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; wrote: </pre> Brian Maso 2013-05-18T21:03:30 http://permalink.gmane.org/gmane.comp.lang.scala.user/63387 <pre>Well, I'm hoping other people might get involved to help with that :) There are still some MySQL and PostgreSQL types pending (like HSTORE on PG and SETs on MySQL) and I'd like to do them before trying integrations, but it's Apache licenced, anyone can fork and contribute back. - Maurício Linhares http://mauricio.github.io/ - http://twitter.com/#!/mauriciojr On Sat, May 18, 2013 at 5:26 PM, virtualeyes &lt;sit1way-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; wrote: </pre> Maurício Linhares 2013-05-18T20:57:40 http://permalink.gmane.org/gmane.comp.lang.scala.user/63386 <pre>Game changer if it works as advertised ;-) Thoughts re: integrating with Slick, Squeryl, etc.? On Saturday, May 18, 2013 7:45:38 PM UTC+2, Maurício Linhares de Aragão Junior wrote: </pre> virtualeyes 2013-05-18T20:26:21 http://permalink.gmane.org/gmane.comp.lang.scala.user/63385 <pre>Yeah, I felt the same, looking at the nodejs community they had all of this in place, I thought it was time we had that too :) - Maurício Linhares http://mauricio.github.io/ - http://twitter.com/#!/mauriciojr On Sat, May 18, 2013 at 12:12 PM, Brian Maso &lt;brian-zVB9M1GYnxxPzT/ju5Bd1kEOCMrvLtNR&lt; at &gt;public.gmane.org&gt; wrote: </pre> Maurício Linhares 2013-05-18T17:45:38 http://permalink.gmane.org/gmane.comp.lang.scala.user/63384 <pre>Holy moly that's cool... I think the Java world has been waiting many years for async database access. Can't wait to check it out. On Sat, May 18, 2013 at 7:58 AM, Maurício Linhares &lt; linhares.mauricio-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; wrote: </pre> Brian Maso 2013-05-18T15:12:18 http://permalink.gmane.org/gmane.comp.lang.scala.user/63383 <pre>I have just released a newer version of the postgresql-async project, an async database connector for PostgreSQL written in Scala and I'm happy to announce that now there is also a mysql-async project that also offers an async connector for MySQL. Both projects use Netty as their network communication framework. The project aims to offer a simple way to talk to both PostgreSQL and MySQL in an async way and with a simple "send a statement, get a future result back" approach. It is not supposed to be a full replacement for JDBC or anything like that, it's just direct database access as simple as possible. Scala 2.10 is required due to the use of the new scala.concurrent.Promise and scala.concurrent.Future objects. Both drivers offer basic and prepared statement support, transformations for commonly used types and support for most of the types offered by the database. You can read the README's available to see how types are translated between db -&gt; Scala. You can read more about this release here -&gt; http://m</pre> Maurício Linhares 2013-05-18T14:58:36 http://permalink.gmane.org/gmane.comp.lang.scala.user/63382 <pre>Well, as I said, FRP can have its own drawbacks (space and time leaks) especially if you allow event switching (= dynamic changes in the reactive graph; these typically come from implementing (or trying to implement) a 'Signal Monad' instead of just an Applicative Functor).* *If you are interested in this topic (especially if your focus is on referential transparency) you can check out *dire*&lt;https://github.com/stefan-hoeck/dire&gt;which provides a referentially transparent FRP implementation based on scalaz. As I said, it's experimental stuff but I already use it in my own projects and enjoy it so far. There's also a link to a blog where I describe some of the design decisions behind *dire* in random order. Cheers, Stefan Am Freitag, 17. Mai 2013 23:41:48 UTC+2 schrieb raould: </pre> Stefan Hoeck 2013-05-18T12:56:33 http://permalink.gmane.org/gmane.comp.lang.scala.user/63381 <pre>Not sure I understand the question. Depending on the context, I might use the previous answers,or also use abstract types : *type *Foo *type *Bar &lt;: Foo You can even go as far as writing *type *Bar &lt;% Foo which mean that there is a way to implicitely convert Bar to Foo ; it may be by standard inheritance,or by an implicit method. At this stage,you've just said there will at some time exist a class Bar and a class Foo,and that Bar will extend (or be convertible to) Foo. How you will later fill up that requirement is undefined at that point (can be classic inheritance, trait mixin, implicit conversion...) Then, there is no *best way*. There is no such hierarchy of good or bad ways. There are several ways to achieve the same thing, which then lead to different ways of coding and using your classes. You have to make the decision by estimating which solution suits better your situation. Yves Le vendredi 17 mai 2013 17:24:26 UTC+2, Julien Richard-Foy a écrit : </pre> yves 2013-05-18T11:52:54 http://permalink.gmane.org/gmane.comp.lang.scala.user/63380 <pre> The problem is the implicit *conversion*. Try this (note that the parameter of the implicit is itself implicit): trait Foo[A] object Foo { implicit def fromBar[A](implicit bar: Bar[A]) = bar.foo } trait Bar[A] { def foo: Foo[A] } // usage def f[A : Bar](a: A) = g(a) def g[A : Foo](a: A) = a Putting `fromBar` into `Bar`s companion object won't work, because when calling `g`, the compiler doesn't look inside that object (by default). Importing would work, though. Do you control `Foo` and `Bar` in your own code? If so, I strongly suggest going with the inheritance approach. It makes your life much easier. If you really have the situation that you can't modify a `Foo` instance, you can still have `Bar` extending `Foo`, and do something like this: object Bar { trait FromFoo[A] { def foo: Foo[A] // implement proxy methods to `foo` def frobnicate = foo.frobnicate // ... } } and then you can write: implicit object IntIsBar extends FromFoo[Int] { // only implement `Bar` methods</pre> Lars Hupel 2013-05-18T10:34:45 http://permalink.gmane.org/gmane.comp.lang.scala.user/63379 <pre>In my codebase I have a single '\0' (i.e. ASCII NUL literal), and a bunch of Strings containing "...\x00...\x00...". So it's easy enough to work around, but a bit annoying that it's triple the length. :) -0xe1a </pre> Alex Cruise 2013-05-17T22:17:07 http://permalink.gmane.org/gmane.comp.lang.scala.user/63378 <pre>Please, please - make octal go away. It has been way too many years since I used a PDP-8 Cheers, Eric On Fri, May 17, 2013 at 2:59 PM, Simon Schäfer &lt;mail-T9T+zHmyPJ+ELgA04lAiVw&lt; at &gt;public.gmane.org&gt; wrote: </pre> Eric Kolotyluk 2013-05-17T22:07:08 http://permalink.gmane.org/gmane.comp.lang.scala.user/63377 <pre> On Friday, May 17, 2013 3:01:18 PM UTC+2, Simon Ochsenreither wrote: I just implemented syntax highlighting for them in the IDE, do you want to tell me that all my work was for nothing? Just kidding, have never used them in practice. I'm fine with killing them. </pre> Simon Schäfer 2013-05-17T21:59:27 http://permalink.gmane.org/gmane.comp.lang.scala.user/63376 <pre> how does that approach compare to other FRPs (in other languages)? seems to me like people often re-tread this issue. </pre> Raoul Duke 2013-05-17T21:41:48 http://permalink.gmane.org/gmane.comp.lang.scala.user/63375 <pre>I should have been more specific: *Functional* reactive programming (though I am well aware that it can have its own shortcomings; and of course it can be implemented using listeners in the background). Concerning circular data flows, this is how I do it in *dire*: A reactive dependency graph is an isolated entity, hidden from clients. There is an Actor responsible for updating (parts of) the reactive graph whenever another part changes (fires an event). This might lead to new (circular) requests to update the graph which are sent back to the master Actor. So there is a delay before circular calls are processed and they are guaranteed to being processed only when the rest of the graph has been updated. So far this seems to work out well, but then *dire *is a work in progress so it still has to proof its worth. Cheers, Stefan Am Freitag, 17. Mai 2013 23:17:37 UTC+2 schrieb Oliver Ruebenacker: </pre> Stefan Hoeck 2013-05-17T21:38:37 http://permalink.gmane.org/gmane.comp.lang.scala.user/63374 <pre>I don't think it's possible to work out "all" the glitch bugs; it's simply a tradeoff on how much glitching you can tolerate v.s. how much rigidity you can tolerate. If you're happy to statically fix the dataflow graph once and for all, you can topo-sort the whole thing and have no glitches, but programming that way is no fun. The more flexibility in modifying/etc. your dataflow graph dynamically, the more glitching you're gonna get. If you want parallelism, then that's more glitching, no way around it =D. Not sure what you mean by ordered inter-relations. source: I wrote Scala.Rx On Fri, May 17, 2013 at 5:17 PM, Oliver Ruebenacker &lt;curoli-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt;wrote: </pre> Haoyi Li 2013-05-17T21:35:13 http://permalink.gmane.org/gmane.comp.lang.scala.user/63373 <pre> Nah. You weren't talking about circular data flow. (Which would be... interesting unless you have a function with a fixpoint.) You were talking non-determinism, as far as I can tell. Reactive programming makes data flow explicit and declarative, i.e. the opposite of non-determinisim. </pre> Bardur Arantsson 2013-05-17T21:33:47 http://permalink.gmane.org/gmane.comp.lang.scala.user/63372 <pre> Hello, I thought using listeners is a form of reactive programming. ;) Seriously, what is the solution? Being so restrictive that circular data flow is impossible? Or something clever to sort it out? Take care Oliver On Fri, May 17, 2013 at 12:10 PM, Stefan Hoeck &lt;efasckenoth-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt;wrote: </pre> Oliver Ruebenacker 2013-05-17T21:17:37 http://permalink.gmane.org/gmane.comp.lang.scala.user/63371 <pre> 1) how do you specify such ordered inter-relations in reactive programming? 2) is there a reactive programming library that actually has worked out all the update glitch bugs? (seriously, not trying to be huffy or snarky.) </pre> Raoul Duke 2013-05-17T20:52:17 http://permalink.gmane.org/gmane.comp.lang.scala.user/63370 <pre> And is there really such a thing as a little too greedy? http://en.wikipedia.org/wiki/Greed On Fri, May 17, 2013 at 11:23 AM, Ryan LeCompte &lt;lecompte-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; wrote: </pre> Som Snytt 2013-05-17T18:47:31 http://permalink.gmane.org/gmane.comp.lang.scala.user/63369 <pre>You can also make it less greedy with the uncertainty operator, ? Your example followed by the amendment: scala&gt; val uri="ftp://user:password-WQCBuIXaXYjQT0dZR+AlfA&lt; at &gt;public.gmane.org/directory/file.xml" uri: String = ftp://user:password-WQCBuIXaXYjQT0dZR+AlfA&lt; at &gt;public.gmane.org/directory/file.xml scala&gt; val Regex = """^ftp://(.*):(.*)&lt; at &gt;(.*)/(.*)""".r Regex: scala.util.matching.Regex = ^ftp://(.*):(.*)&lt; at &gt;(.*)/(.*) scala&gt; def f1 = uri match { | case Regex(userName,password,host,fileName) =&gt; | fileName | } f1: String scala&gt; f1 res0: String = file.xml scala&gt; val Regex2 = """^ftp://(.*):(.*)&lt; at &gt;(.*?)/(.*)""".r Regex2: scala.util.matching.Regex = ^ftp://(.*):(.*)&lt; at &gt;(.*?)/(.*) scala&gt; def f2 = uri match { | case Regex2(userName,password,host,fileName) =&gt; fileName | } f2: String scala&gt; f2 res1: String = directory/file.xml On Fri, May 17, 2013 at 11:23 AM, Ryan LeCompte &lt;lecompte-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; wrote: </pre> Som Snytt 2013-05-17T18:45:19 Search the mailing list at Gmane query http://search.gmane.org/?group=$group=gmane.comp.lang.scala.user