Pike-devel October 2016

pike-devel@lists.lysator.liu.se

4 participants
13 discussions

Promises in Pike vs other languages
by Marcus Agehall (nu med K-m�rkt fastighet och ny elcentral) ＠ Pike (-) developers forum 09 Nov '16

09 Nov '16

I have spent some time looking at the new stuff in Concurrent.pmod that Grubba has added to 8.1. Mostly it is code relating to the concept of Promises and Futures which are very popular amongst JavaScript people these days. I have noted that there seems to be some rather striking differences between how JavaScript treats promises and how Pike does it. I'm not sure this is a good thing(tm) and therefore I'd like to bring this up before 8.1 stabilizes. In Pike, we have two methods that register callback functions, Future.on_success() and Future.on_failure() as opposed to JS where only one method, then(), is used to register both callbacks. I don't mind having two different methods, but for easier transition between the two languages (i.e. for people writing both client-side and server-side code) having the same API would probably help. A bigger problem imho is the difference in how promises are actually resolved. In JavaScript, the return value of then() is always a *new* promise which then allows for chaining. In Pike, we return the same promise object. This means that code like my_promise->on_success(foo)->on_success(bar) in Pike would result only in a call to bar() once my_promise is resolved whereas in JavaScript, foo() would be called and it's return value would be the input to bar in a new promise. The whole creation of promises is also somewhat awkward in Pike. In JS, you simply pass a callback that will do all the work and that will recieve a success callback and a failure callback as arguments and off you go. In Pike, I'm not sure what the best way to do it is. I really like the idea of having promises in Pike, but would it not be much better if we tried to implement an API more similar to what the JS folks are used to? At least I think so... Here are three links to good resources I've found regarding promises in JS. I'm sure there are a ton of others as well. https://promisesaplus.com/ http://www.mattgreer.org/articles/promises-in-wicked-detail/ http://bluebirdjs.com/docs/api-reference.html

4 10

Proposal: Checked subprocess calls
by Chris Angelico 06 Nov '16

06 Nov '16

Branch: rosuav/process-check-run Two features added to the Process module. Firstly, a simple wrapper Process.check_run that calls Process.run and throws an error if the exit code isn't 0; and secondly, a means for Process.run() to leave stderr attached to the console. The intention is for this to be used for subprocess invocations that should normally succeed, but which might fail under exceptional circumstances: https://github.com/Rosuav/shed/blob/master/double_compile.pike string build = Process.run(({"pike/bin/pike", argv[0], "-x", argv[1]}))->stdout; The intention is for this to run a process and return its stdout. I could, of course, manually check: mapping rc = Process.run(({"pike/bin/pike", argv[0], "-x", argv[1]})); if (rc->stderr != "") werror(rc->stderr); if (rc->exitcode) exit(1, "Oops\n"); But with this proposal, the code would look like this: string build = Process.check_run(({"pike/bin/pike", argv[0], "-x", argv[1]}), (["stderr": "-"]))->stdout; It's a fairly simple idiom (and it might be worth making check_run set stderr to "-" by default), and 99% of the time, it'll do the same as the equally-simple idiom that I currently use for any quick-and-dirty scripts - but if something goes wrong, check_run will make sure that you don't miss noticing it. There are, broadly speaking, two ways for a subprocess to signal that something went wrong: a message on stderr, or an exit code. They're handled independently (check_run looks for the exit code, and setting stderr to "-" lets the user notice an error message), so you can pick and choose. Is this something wanted in trunk? ChrisA

3 7

Re: Promises in Pike vs other languages
by Per Hedbor () ＠ Pike (-) developers forum 07 Oct '16

07 Oct '16

Something I would recommend, from having written heaps of asynchronous object based systems, with or without remote computers involved, is to treat all references to the promise object going away as an error, and avoid un-needed circular references. This makes it easy to detect when you accidentally forget the object. Also, having the object be callable is rather convenient, it can then be put as a normal callback in all the various function based API:s we already have. >From the MiniRPC module, used extensively in the mini codebase: // This is an object representing a function to be called when // whatever task is being requested has been completed. // // In the RPC case the 'call_id' and 'par' are used to send the return // value, and function_name is for debug purposes. // class ReturnFromCall(protected int call_id, protected object par, protected string function_name) { protected void destroy() { // this should check the done function callback instead.. if( call_id ) { werror("Return was never called for "+function_name+"\n"); if( par ) this.error("Return was never called\n"); } } protected string _sprintf( int flag, mapping opts ) { // It's rather nice to have a _sprintf for backtraces. But // without a function_name it's harder :) return sprintf("ReturnCall(from %O)", function_name ); } protected void error(string err) { // .. this is sort of special in the RPC code .. call_id = 0; destruct(this); } void `()(mixed ... x ) { // Wanted addition #2: Callable promises? call_id = 0; destruct(this); } mixed try( function x ) //! Call @[x], if the call fails report an error message to //! the remote side. // // syntax of the day: // foo( foo->try() { code to run..; return res;}); // // It might be useful to have a functon that also returns the // value calculated { if( mixed err = catch{return x();}) { // code goes here to log etc.. this.error(err); } } } Also, I personally belong to the "future/promises don't really add much" camp, but feel free to add the API. :) (In my opinion it's just another way to complicate asynchronous programming)

4 7

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

Pike-devel October 2016