StarWarsArrays.jl VS hebigo

I raise you https://github.com/giordano/StarWarsArrays.jl

Why not Star Wars Indices (4,5,6,1,2,3,7,8,9...)? https://github.com/giordano/StarWarsArrays.jl

> The documentation disagrees about string indices not starting with 1 As priorly said, I'm speaking about strings, not `String` in particular. So, to write code which work for all AbstractString (which have basic string functions), you must not assume that the first indexing is 1, you can have degenerate cases such as : https://github.com/giordano/StarWarsArrays.jl (this is for vectors, but creating a similar type, for AbstractString isn't impossible) or just strings with an offset indexing.

There are other choices like https://github.com/simonster/TwoBasedIndexing.jl and https://github.com/giordano/StarWarsArrays.jl if you do not like 1-based indexing.

This is a total non issue as indexing is an operation that is subject to multiple dispatch. For a humorous example see https://github.com/giordano/StarWarsArrays.jl

The cool thing with Julia is that array indices aren't inherent properties, and may be changed locally by using appropriate wrappers. This means that the same underlying array may start at 0 in one part of the code, at 1 in another, and perhaps use the star-wars indexing in yet another section if that's necessary.

Adding https://github.com/giordano/StarWarsArrays.jl to the list for some extra spice

You should also check out https://github.com/giordano/StarWarsArrays.jl and https://github.com/giordano/RandomBasedArrays.jl

The Lissp transpiler incrementally compiles and executes each top-level form to Python. It needs to do this in case there's a macro definition that might affect the compilation of a subsequent form. If it's only executing definitions, this is harmless, but if you want to precompile the main module, it needs the guard, or the side effects will happen too.

If you want Python to be as customizable as Lissp, check out Hissp (and Hebigo).

Python's lambdas can have as many lines as you want. Just wrap parens around it. Hissp uses this form as a compilation target. Its REPL shows the Python compilation. Play around with it til you get it: https://github.com/gilch/hissp

The original Lisp's S-expression syntax was just supposed to be an intermediate language used by the compiler when processing the real language based on M-expressions, which kind of never took off. Numerous alternatives to S-expressions have been proposed, and some retain homoiconicity, another feature diagnostic of a Lisp (and one that ECMAScript lacks). For example, see Hebigo's readme, which shows a direct correspondence between its Python-like syntax and that of Hissp's default reader (Lissp), which uses the S-expressions. Julia can also be written in S-expressions, but this usually only used in macro definitions.

I think LoL is too CL-specific. If you know both languages first, you can pretty much translate, but since they'd be trying to learn Lisp in the first place, this is a bad idea.

On the other hand, [Hissp][1] has a pretty good tutorial for anyone coming from a Python background.

[1]: https://github.com/gilch/hissp

Hebigo: a whitespaceLisp isomorphic to Hissp that looks like Python.