@OderWat: Yes, this is already the case with the `AsyncHttpClient`. I plan to
introduce a `HttpClient` also which will deprecate the current synchronous API.
Thank you. It worked with the "cL" at the end.
@smitty Well, at first I suggest that you try what is working in
[linalg](https://github.com/unicredit/linear-algebra) and let me know what you
don't like or what is not clear in the documentation (I know, they should be
expanded and there should be a tutorial as well). :)
>From there, there ar
@Araq: It was a bit bussy at work, so I didn't find the time yet to post the
bug on github. But I noticed it was alread fixed :) Thanks for that.
I can confirm that the fix indeed fixes the crashes I my program. Thanks again
for the very fast fix.
I think there need to be two of them at the end (at least if there is some body
content which could even be there with GET). I also think this should be
handled by the http client. And headers should be a sequence or an array
instead of a "string which works if you know how".
Please create an issue for this.
I think you might need to add another `division` at the end of the `headers`.
I'm trying to execute a simple request adding some headers but it fails with
time-out. Here's my test code:
import httpclient
const division :string = "\c\L"
const userAgent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36
(KHTML, like Gecko) Windows Chromium/51.0.
@andrea sure, where to start? I'd like to see nimlibs for scipy, pandas and
matplotlib (perhaps wrapping plplot). The prospect is daunting :)
Hi Peter,
I knew the shadow variable looked too easy! Oh well... :)
( sorry if I keep asking obvious questions, I'm not used to handling memory and
the like. I'll have to read up on how memory is handled by nim, the gc, etc )
So you have compile master> master runs block1, forwards its
memory/
Is there any documentation on how this should work? How would it be possible to
define a memory region and then later destroy it? And will there be a mechanism
to test weather a memory region as still some active references in it?
Just wanted to say: the plan looks really nice! I do not see any obstruction in
just transforming this into an independent interpreter, so if everything works
out fine I hope it will eventually lead to a resurgence of `nim i` :)
Hi Silvio,
My plan is the following: the python code compiles the master, the master
compiles and runs block1. Here block1 is modified (we add a bunch of stuff
before and after the code) before compiling. And the magic: block1 compiles
block2, and runs it, etc.
The `-d:release` flags do many t
@mora: Sounds like a good plan!
I'm still relatively new to nim, so it's probably more detailed than anything I
would have thought of.
A couple of questions, sorry if they are obvious / make little sense:
> The python wrapper will pass the code this binary, which will compile it, and
> call it
The no GC future is `--gc:stack` which replaces the GC with memory regions. So
any library that uses the GC really uses a memory region. The entire situation
is ok. Note that the GC is always thread local anyway, so you can also just run
realtime threads with other threads that use the stdlib an
https://github.com/nim-lang/Nim/issues/4653
For anyone interested, there is some [solver
functionality](https://github.com/unicredit/linear-algebra/blob/master/tests/funcs.nim)
via lapack in
[linalg](http://forum.nim-lang.org///unicredit.github.io/linear-algebra/).
@smitty Would you be interested in contributing? :)
I cant find any information. What happens if I use a nim library that uses a
GC? I'll be "infected" with its problems. This entire situation seems terrible.
I started to play with it. My plan is to keep the python wrapper. The reason is
simple: I'm comfortable with python, I don't want to support multiple threads
in Nim, and I want to send a kill signal to the process if the user wants to
interrupt (menu Kernel->Interrupt in Jupyter) a long running
Request body is readed in memory at once. So, we can't receive big `POST`
requests. Maybe we can introduce new type, `RequestBody`, that can be used to
get body as a string/file/stream/whatever, or maybe even handle
`application/x-www-form-urlencoded` or `multipart/form-data mime types`?
just sharing/archiving.
fortran wrapper:
! lapdog.so
! f95 -shared -o lapdog.so types.o constants.o utils.o lapack.o linalg.o
lapdog.o -llapack
module lapdog
use linalg, only: solve ! https://github.com/certik/fortran-utils
use iso_c_binding, only: c_int, c_doub
21 matches
Mail list logo
