i thought clojure interop with python would be really useful, I'm thinking something like clojurescript, but for python instead. anyone else think this is a good idea?

I bet @tbaldridge has some thoughts about that :)

https://github.com/pixie-lang/pixie/

I forget how many versions of that he’s done - at least a few if I remember correctly

pixie doesn’t do python interop though - it only uses a python vm

(I guess it can do python interop on a compiler level? not in the runtime)

there's this https://github.com/drewr/clojure-py/

but it's not updated

Hy has a similar syntax to Clojure: http://docs.hylang.org/en/stable/index.html

but it doesn't interop with python...?

http://docs.hylang.org/en/stable/language/interop.html

if you mean pixie - it uses rpython to make a vm, but doesn’t have access to python at runtime

oh oops, it does!

yeah there's a lot of differences between python and clojure that makes it hard

oh!

I used to maintain clojure-py back in the day

i see.

it had a lot of problems though

is there one problem that you remember?

one of clojure's strengths is really the interop. every few days someone asks on r/clojure about clojure and data science

i think these questions would go away if there was a clojure that could interop with python

mutable closures, reference counting, reference counting that defults to borrowing (everything holds onto the head)

sort of like clojure for the CLR

i see

python is also rather slow, so if you want something liek clojure-py you need part of it to be in c

or make everyone use pypy

what about a clojure vm that knew how to consume the python wrappers of c and fortran stuff? (I ask, knowing nothing about how python ffi works or whether that question even makes any sense)

perhaps the real killer app for python in data science isn’t the wrapped libraries from c/fortran but the higher level stuff in python that consistently works together and builds on that - if so competing is going to be a lot more work

The other thing that makes this really hard is that it's hard to define what Clojure is.

Stuff like multi-arity functions don't exist in Python. So do we need to implement something like IFn and pay the cost of two dynamic dispatches on every function call?

What is even the core protocols needed by Clojure? CLJS and CLJ are really different in the protocol area, and some of the CLJS stuff is pretty JS specific.

so the few times I've looked into it I got bogged down in trying to figure out how to map Clojure semantics to Python

For example in Clojure falsey is nil and false. In Python it's: None, False, [] and 0.

would you be interested in working on this again if you had someone to help you? 😛

I bet you could get some traction with a docker image set up to run jvm clojure using blas and some good matrix and stats libs out of the box

i think javascript is different if it's falsey too

i'm glad i talked to you, you have so much experience!

@ackerleytng I'd be willing to give people pointers. But at this point if I'm going to write a language, there's other non-Clojure concepts I want to explore.

i see, ok!

Effect systems, fully immutable VMs, etc.

but then you'd have to reimplement numpy

@tbaldridge ok first question! how did you even start? by reading the clj/cljs implementation first?

pretty much, the stuff in clojure.lang is pretty simple. A good way to start is by looking at clojure/core.clj and seeing what stuff like conj calls, then dig into clojure.lang.RT, and that then takes you into all the other code.

Oh, that reminds me of something else that's a bit hard to implement:

No Clojure implementation out there has first-class Vars and protocols on the bottom.

CLJ has vars, but not protocols at the bottom

CLJS has protocols at the bottom, but not vars.

heh, that is tricky indeed

Python could have both, but that's a really nasty chicken-egg problem. To get vars you need hashmaps, and some other structures. To get that you need protocols. Protocols are stored in Vars....

I've played with fully self-hosted clojure a bunch of times and that's always been the biggest headache

😄

@tbaldridge you don't actually need hashmaps tho, there's a few tricks you can play to defer hitting code paths where those would be needed, until they are defined

but they don't make for pleasant or very understandable code

I found that a bigger headache than the circular dep between vars and protocol is the one between vars, namespaces and symbols

which makes me think -- I've heard RH say that if he was to redo the var/ns system he would make it significantly less reified

I'd be curious to know which parts he'd do away with

@alexmiller any ideas on ^ ?

Nope

I just want to get rid of Namespaces as mutable Java objects :)

that would be amazing

but also a massive breaking change

mostly for tooling I reckon

Maybe, figuring that out would be step 1

Someone did a spike on immutable namespaces a few years ago iirc

immutable namespaces come with their own sorts of problems

Yup

it's not the awesome happy land people think they would be :)

But imagine that refer-clojure was just adding a pointer

i've spent long evenings imagining that

oh I know - namespaces made of datoms

(kidding)

there's kiss from mikera that has immutable namespaces

but it's just a long-running experiment as far as i can tell

Maybe that’s what I’m remembering

now called magic, just like ra's compiler

to add to the confusion

ocaml is the closest you'll get to having "immutable namespaces"

Nice :)

and redefinition in ocaml is just not a thing

and mutual recursion needs to be compiled in a single compilation block

etc

Well if it’s indistinguishable from magic then it must be sufficiently advanced

hehe

(altho the lack of redefinition in ocaml is considered an intentional feature)

@bronsa it blew my mind when I found out that F# kept all those "features"

one of the reasons I learned Clojure instead.

brb implementing OClojml

you're kinda forced to do that in a staticly typed lang

otherwise redefinition would invalidate all your types

what a mess that would be

I've never looked at F#

It's pretty much what you'd expect if you built Clojure on .NET and used OCaml as a base instead of lisp.

that doesn't actually sound too terrible :)

Microsoft have really good tooling and language designers as well

If Clojure didn't exist I'd probably be doing F# instead, I rather like it.

I like it but never liked the non windows environment for it although I hear it's better now

I love the contrapositive of Clark's third law: Any technology distinguishable from magic is insufficiently advanced.

haha

F#'s tooling was pretty rough last I tried. It also ends up being pretty verbose at times.

TBF so is ocaml's tooling IMO

Want to like it, but it def. suffers from MS' documentation problems

I really like F# (what little I've used it). The providers stuff is awesome.

using ocaml's tooling feels like using common lisp before quicklisp was a thing

with the only upside that there's not 15 different incompatible implementations

have you used opam? it’s a little clunky but at least it does switchable version isolations

yeah I have

opam2 is a massive improvemnt over opam1

but still quite clunky

compared to what I'm used to at least

jbuilder is also quite nice (I forget what they renamed it to)

I haven’t made a new OCaml project recently enough to try jbuilder