@quartata nice!

_ isn't valid identifier?

It's in the design but we haven't fully fleshd it out. It'll do more things

@Maltysen Yes but it's special. It is in Python too

and Erlang

@quartata i know

but what happens if I do _=5 before that

Error it isn't a variable

oh

_ is meant to evoke the idea of "fill in the blank". It's filled in by loops and functions, generally.

At least not an lvalue. We called it a blank in the original design

cuz in python that would work

but that's cool

kinda like prolog

Was this even how it worked with functions? I thought it was... :P

anyways \f(2, _, 4)(3)

@quartata Yeah, that would work. \f(2, _, 4) is effectively equivalent to lambda x: f(2, x, 4) in Python.

Yeah, exactly. I think that's good because one link chains aren't really a clean way of doing that

@El'endiaStarman so it does partial applications without the chain stuff from before?

@Maltysen ...what are partial applications, again? I know I've had that explained to me, but I don't remember anymore.

Currying

> lambda x: f(2, x, 4) in Python.

@quartata And I barely know what that is too. :P

@El'endiaStarman currying is when you have 1 function with n args and you make it n functions with 1 arg each

To answer the question yes.

@Maltysen I think that's actually the best explanation I've heard of for it.

partial application is kind of like automatic currying

Chains are for things like this: f(g(x), h(y)) to x, y~>\g, \h->\f

@quartata what associates with what looks really hard to remember

It's FIFO

?

An argument queue is maintained where functions take arguments from the front and their results are pushed on the back.

The chain is broken up into links. At each link every function polls the queue for its arguments and st the end offers the results back

yeah what elendia said

Variables and literals just return themselves

oh, is ~> different from -> like one is vectorized and the other splats?

-> creates the chain. ~> calls it

And yes ~> splats the initial args onto the queue

← 39 messages moved from The Nineteenth Byte

whoosh

boom

quaternions!?

@Maltysen Ohhh YES... :D

Hell yeah

If that doesn't sell you I don't know what will

oh _ isn't allowed at all in identifiers?

@Maltysen It is, just not as the initial character.

spec doesn't mention that

just says alphanumeric

Spec is probably out of date. :P

also, <=> as cmp is cool

Spec is pretty old. It's from at least half a year ago

comparisons chain, right?

Yes, of course.

That's implemented already, in fact.

@Maltysen <=> I stole from Perl

And comparisons chain like Python

I wonder if we should add |=| as an easter egg that goes "Pew pew BOOM!". :P

We also have interval notation for ranges

I would use pytek except for \function

seems unnecessary and annoying IMHO

Ahhh not another one of you \-haters.

awh come on everyone says that :( we had a good reason

@quartata which was...?

"Distinguishes functions from the rest" was one of the reasons, IIRC.

It makes it far easier to differentiate functions yeah

especially when passing them

how about you do a lisp2 like thing

where you have \ when passing

but not when calling

Erlang does that and it drives me nuts, I always forget

Have to do fun add or whatever

Ambiguity is another issue. We're using \foo[] for options, much like named arguments in Python, and if there's no \, then foo as a function can't be distinguished from foo as a list (where [] is indexing/slicing like in Python). Except at run-time.

@El'endiaStarman why [] for named args?

Looks good and all of the other symbols have similar problems anyways

Semantics. It's nice to put options that affect how the function operates in one place and the actual arguments in another.

Also not just named args \input[UTF_8]()

Also used in for loops: \for[element](list)

@El'endiaStarman Although I though we were not using [] for indexing anymore

@quartata Ohhh that's right, we changed that.

Yeah we use dot now. list.2 or list.(0..3]

Also we're using \() { ... } instead of < ... > for lambdas right

don't remember if we decided

@quartata Correct. That's implemented.

By the way I think we should try to get the parser in a semi working state then start porting to Cython; I fear if we wait too long it'll be too big

Cython is what i decided would be better than RPython. In essence it lets us have statically typed variables that are super fast

Keeps things more or less the same except you have cdef int x = 0 in place of x = 0

Gotta go. Something to consider is all

Sounds good. I'll let you take care of that. :P

@El'endiaStarman what happens if I do x=5 then try to assign x to a function?

@Maltysen As in x = \f?

yeah

That should work, I think, but you'd still have to do \x() to call it.

i see

@El'endiaStarman halp pytek has all cool feature and cheddar has cheese puns ;_;

@Downgoat At least you don't have people hating on the \...

I'd say that counts more as a feature than a con

@Downgoat At least you have something that's almost complete

I can't see us releasing Pytek on GH until sometime early next year

and that's optimistic

@quartata It works? Definitely. Complete? I wouldn't say so, but I guess it's close to all features for its first release. Performant? Far from it, but I guess it's good enough for now

So in my opinion, we can't really compare progress like this

Plus, I'm pretty sure Pytek wasn't worked on for quite a while

Cheddar is pretty much almost complete. Most of the other things the stdlib might need shouldn't be in the official release but should be provided by the community as packages. (which is why you should fix your package manager :P)

The only thing it's missing, really, are generators.

The STDLIB will need to be redone to use them which will take a while but that's it

@quartata haven't even worked out the workings of package manager even :P

I also want to integrate it with cheddar and do it in C++ as practice