Pike-devel August 2019

pike-devel@lists.lysator.liu.se

7 participants
12 discussions

Pike Meet-up 2018-Q1
by Henrik Grubbstr�m (Lysator) ＠ Pike (-) developers forum 20 Oct '21

20 Oct '21

Hi. At Pike Conference 2017 it was decided that we ought to hold a more informal meeting in Linköping ~ once every quarter. As the three month mark from the conference is coming up soon, it seems time to announce the first such meeting for 2018: Pike Meet-up 2018-Q1 Date: 2018-02-03 (Sat) Time: 10:00 - afternoon/evening Place: Roxen IS AB S:t Larsgatan 22A Linköping Welcome! /grubba

2 13

Operator assignment and strict_types
by Marc Simpson 07 Jul '20

07 Jul '20

Hi folks, It looks like operator assignment (op=), increment and decrement statements aren't subjected to the same typechecks as their more explicit equivalents. For example, neither the post-increment nor += statements below warn with strict_types enabled, even though they assign values outside of foo's restricted int domain: int(3..3) foo = 3; foo++; // no warning foo += 1; // no warning foo = foo + 1; // warning from strict_types Similarly, operator assignment on aggregates fails to elicit a warning: array(int) a = ({}); multiset(int) b = (<>); mapping(int:int) c = ([]); // no warnings a += ({ "hey" }); b += (< "hey" >); c += ([ "hey": "there" ]); // warnings from strict_types a = a + ({ "hey" }); b = b + (< "hey" >); c = c + ([ "hey": "there" ]); I'm guessing this is because the checks provided by the F_ASSIGN/F_ASSIGN_SELF case (las.c) only apply to direct assignment; op= and friends are presumably not instrumented for strict_types in the same manner. Have there been any discussions around addressing this inconsistency? Thanks, Marc

3 3

Remixml, javascript module
by Stephen R. van den Berg 25 Feb '20

25 Feb '20

This might be of interest to the Pike and/or Roxen community: https://www.npmjs.com/package/remixml I just launched it. Using it in a Single-Page-Application website. Any critical feedback is welcome (I'm currently the only user, so changes in the API are easy and still allowed). >From the description: Remixml is an XML/HTML macro language/template engine. The language and primitives used blend in completely with standard XML/HTML syntax and therefore integrate smoothly with existing XML/HTML syntax colouring editors. Requirements It runs inside any webbrowser environment (starting at IE11 and up). For historical reference: Remixml was originally inspired by RXML, the Roxen webserver macro language. -- Stephen.

1 1

Re: debugger, status and suggestions sought
by Mateusz Krawczuk 03 Nov '19

03 Nov '19

I think having both LSP <https://microsoft.github.io/language-server-protocol/> and DAP <https://microsoft.github.io/debug-adapter-protocol/> implementations for Pike would be awsome, but I feel that this discussion is getting further away from it's main point. We've been talking about LSP for a little during the Conference. There is a huge interest in it and I think we should move the LSP discussion to another mailing thread to avoid mixing contexts. Having a Pike debug adapter would also be great, but since DAP is used for estabilishing communication between IDE and the debugger, we can't move on with it until we actually have a debugger. >From what I understand the greatest challenge now would be to reach the local variables. I've heard that long time ago, the language got some optimizations that makes retrieving local variable names very challenging. Is it true? If yes, how we can jump this through? I would be more than happy to help crossing-out the remaining TO-DOs, if I only could get some itroduction and clues.

5 25

Pike conference 2019
by Tobias S. Josefowitz 30 Aug '19

30 Aug '19

Hi, we invite you to this year's Pike developer conference on the weekend of the 2nd and 3rd of November 2019. Opera will host the conference in its offices in Linköping. On Saturday and Sunday we meet at the Opera offices (Repslagaregatan 21) starting from 10:00. Just call "Opera Software" using the fancy door-bell-replacement technology at the entrance (or follow instructions as posted on the door, if any). Even though asking for this has traditionally proved somewhat pointless with our crowd, why don't you drop me an email to let me know should you want to join. On Friday the 1st of November 2019, Roxen invites everyone who is already in town and available at 15:00 to the traditional pre-conference fika at the Roxen office at S:t Larsgatan 22a. If you want to schedule an item on the conference agenda or have any other questions, please just send me an email. On behalf of the 2019 conference committee, Tobi

1 0

Broken online documentation
by Tomasz Jamroszczak 27 Aug '19

27 Aug '19

There's no System.Tiem in the documentation. I can access it via Google Search cache: https://webcache.googleusercontent.com/search?q=cache:5nqNuHyJgzAJ:https://… Best Regards, Tomasz Jamroszczak

1 0

Re: Comments/thoughts requested: Generators and async functions in Pike
by Chris Angelico 27 Aug '19

27 Aug '19

On Tue, Aug 27, 2019 at 3:26 AM Henrik Grubbström (Lysator) @ Pike (-) developers forum <10353(a)lyskom.lysator.liu.se> wrote: > > > Pike now (8.1) has a decent promise/future subsystem. It's always had > > great handling of multiple asynchronous operations (GUI, socket, time > > delay, etc) with the convenience of just returning -1 from main. > > Interested in people's opinions on whether it would be of value to > > introduce generators and (built on them) asynchronous functions. > > > > I'm borrowing terminology heavily from Python and ECMAScript here, and > > both of them have drawn from prior art. > > > > A *generator function* is a function that can be partially run, then > > set aside until resumed. Effectively, its stack frame can be > > encapsulated in an object for future use. It would look something like > > this: > > > > int get_numbers() { > > write("Starting\n"); > > yield 1; > > write("Continuing\n"); > > yield 2; > > write("Finishing\n"); > > return 3; > > } > > > > Calling get_numbers would prepare an execution context, but not > > actually begin running the function at all. The caller would get back > > a *generator object*. Asking this generator object to produce its next > > value would begin executing the function, triggering the call to > > write, and would stop at the first yield point, returning that value > > (1). Asking for another value resumes the function, triggering the > > second write, and returns the next yielded value. The third time you > > request a value, it would run the function to completion, and report > > that it returned (not yielded) 3. > > > > (The types yielded don't have to match the type of the return value. > > I'm not sure if there's a good way to declare the yielded types, or if > > it's best to just assume 'mixed'.) > > Not matching the declared type seems like a bad idea. They're two quite separate types, and there's currently no way to declare that distinction. The type yielded and the type returned could be completely different. For example, when being used for asynchronous code, the yielded type would be some sort of awaitable (a Concurrent.Future or similar), and the returned type would be the actual data to be produced. > > A generator object would be an Iterator, allowing you to loop over the > > yielded values easily: > > This is a separate issue. Note that iterators have both indices and values. Yes, I'm aware of that; would it be a problem if the indices are just all zero? Generators don't have any useful concept of "indexing". > > foreach (get_numbers() ;; int num) > > > > The 'yield' keyword would be an expression/operator, allowing you to > > send a value back into the generator function as the result of the > > yield expression. > > This seems to be something entirely different?? It's the way to elevate generators to coroutines. You produce a value out of the generator, and then either get one back in, or just get a zero that you ignore. > Anyway, I have a proof of concept implementation of the first use: > > --- generator_test.pike --- > > continue int foo(int start, int end) > { > while (start <= end) > continue return start++; > } > > int main(int argc, array(string) argv) > { > function(:int) bar = foo(4, 8); > > int i; > do { > i = bar(); > if (zero_type(i)) break; > werror("%d\n", i); > } while (1); > } > > --------------------------- > > $ ./pike generator_test.pike > 4 > 5 > 6 > 7 > 8 > 0 > > Note that the ending 0 is due to the implicit return 0 at the end of > Pike functions. Yes, which is why the returned value can plausibly be different from the "continue return" intermediate values - you don't use them the same way. Going back to my original async I/O example and recasting it into your syntax: string show_channel_info(string name) { int id = continue return get_channel_id(name); mapping data = continue return query_channel(id); write("Status: %s\n", data->status); mapping stream = continue return get_stream_info(id); if (stream) return sprintf("%s is online, %s", name, stream->uptime); return name + " is offline."; } The intermediate values would be Concurrent.Futures; the caller would get one of them, wait on it, and then send the returned value back in. The final return value is a string. ChrisA

2 2

Use of ::_destruct() in arbitrary objects
by Chris Angelico 26 Aug '19

26 Aug '19

In digging into a problem with Protocols.HTTP.Promise, I came across an issue with inheritance and destructors. #ifdef HTTP_PROMISE_DESTRUCT_DEBUG # define PROMISE_DESTRUCTOR \ protected void _destruct() { \ werror("%O()._destruct()\n", object_program(this)); \ } #else # define PROMISE_DESTRUCTOR #endif Activating this debug flag actually prevents the parent destructors from being called. And simply adding ::_destruct() into there doesn't work either, as that will break for anything that DOESN'T have a _destruct in its parent. How can this be solved generically? The symbol ::_destruct simply can't be looked up (at compile time) if the parent doesn't have one. ChrisA

2 2

Comments/thoughts requested: Generators and async functions in Pike
by Chris Angelico 26 Aug '19

26 Aug '19

Pike now (8.1) has a decent promise/future subsystem. It's always had great handling of multiple asynchronous operations (GUI, socket, time delay, etc) with the convenience of just returning -1 from main. Interested in people's opinions on whether it would be of value to introduce generators and (built on them) asynchronous functions. I'm borrowing terminology heavily from Python and ECMAScript here, and both of them have drawn from prior art. A *generator function* is a function that can be partially run, then set aside until resumed. Effectively, its stack frame can be encapsulated in an object for future use. It would look something like this: int get_numbers() { write("Starting\n"); yield 1; write("Continuing\n"); yield 2; write("Finishing\n"); return 3; } Calling get_numbers would prepare an execution context, but not actually begin running the function at all. The caller would get back a *generator object*. Asking this generator object to produce its next value would begin executing the function, triggering the call to write, and would stop at the first yield point, returning that value (1). Asking for another value resumes the function, triggering the second write, and returns the next yielded value. The third time you request a value, it would run the function to completion, and report that it returned (not yielded) 3. (The types yielded don't have to match the type of the return value. I'm not sure if there's a good way to declare the yielded types, or if it's best to just assume 'mixed'.) A generator object would be an Iterator, allowing you to loop over the yielded values easily: foreach (get_numbers() ;; int num) The 'yield' keyword would be an expression/operator, allowing you to send a value back into the generator function as the result of the yield expression. The awesomeness of this becomes more apparent when combined with Concurrent.Future objects. An asynchronous function would be a generator which yields Futures until it is ready to return a value. Calling such a function automatically returns a ready-to-go Future, set up such that it is automatically transform_with'd the next yielded Future, or transform'd into the returned value. It would be used somewhat thus: void show_channel_info(string name) { int id = yield get_channel_id(name); mapping data = yield query_channel(id); write("Status: %s\n", data->status); mapping stream = yield get_stream_info(id); if (stream) write("%s is online, %s\n", name, stream->uptime); else write("%s is offline.\n", name); } This is WAY more readable than the equivalent with a bunch of lambda functions to capture the intermediate values. Thoughts? Concerns? Questions? ChrisA

3 3

Re: SSL cert for pike.lysator.liu.se has expired
by Chris Angelico 23 Aug '19

23 Aug '19

On Fri, Aug 23, 2019 at 11:59 PM Peter Bortas @ Pike developers forum <10353(a)lyskom.lysator.liu.se> wrote: > > I guess that's me. Fixed. Thanks! I was doing some Pike coding on live-stream today and one of my viewers mentioned it. Appreciate the quick fix! ChisA

1 0

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 August 2019