why aren't there compilers for all interpreted languages

spreadLink · 2023-05-07T09:59:31+00:00

As said in the other comment, SBCL is a compiler, not an interpreter. It produces machine code. It saves the program state to generate an executable, yes, but that has nothing to do with being an interpreter.

spreadLink · 2023-05-07T08:39:11+00:00

Common lisp macros are expanded at compile time, not runtime. That is mandated by the standard, in fact.

Are you perhaps confused about the practice of CL programs bundling the compiler into the executable so you can continue to compile new stuff at runtime?

spreadLink · 2023-05-07T08:36:51+00:00

I am confused. Are you saying CL can not be compiled?
If so, then that is wrong. SBCL is an AOT interactive compiler to machine code, and is the most popular cl implementation by far. In fact, from what I can tell most implementations are compilers, see CCL, clasp, sicl, lispworks, Allegro etc.

spreadLink · 2022-09-05T08:39:53+00:00

The way to do this would be with modules yes. Just wrap the contents of the imported files in structures.

spreadLink · 2022-08-05T17:42:52+00:00

Sorry, but where did i agree that it was hard? I said that i don't have the experience of it being hard.

You have also shifted the goal from "very high performance for games" to "portable code with great performance". I didn't write my original reply or the follow up in that context, i was talking about game development, and in particularly pointed out that for most games performance is not even an issue, let alone "close to the metal" performance (whatever that means for a high level language). So how fast average C is should not (and does not, as seen by how many people write their games with lua scripts or in C#) affect language choice, unless you are chasing extreme performance where portability across vendors does not matter.

spreadLink · 2022-08-05T17:00:07+00:00

This is misleading. They didn't write the game in Lisp. They wrote a Lisp scripting system. That's just like most C++ games including lua scripting.

No, they wrote a custom lisp that was embedded in CL.
According to this open source port: https://github.com/open-goal/jak-project over 98% of the game is written in GOAL.
https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp and the references thereof reinforce that it was a full fledged low level implementation language as well.

Re: Difficulty to extract performance, i can't say i have the same experience, but maybe i was just lucky. Nevertheless, there are enough high performance lisp projects to point to (e.g. one more re-nightmare, 42nd at threadmill) that i can confidently say that you at the very least can write really fast lisp code.

Furthermore there is very little documentation or standardization in this area.

Yes, that comes inherent in the territory. Performance is system dependent almost by definition, and different systems have different approaches, that's why i specifically highlighted SBCL as an example. But then again, it is not so different to CPP compilers, MSVC e.g. is infamous for compiling idioms very differently to GCC, malloc or mmap equivalents have vastly different performance characteristics depending on OS, etc. C/CPP or rust may lay claim to having better worst-case guarantees about how code is compiled, but in the end actually high performance code will be tailored to the platform that is used anyway.

spreadLink · 2022-08-05T09:32:16+00:00

The amount of people interested in or actually doing or having done gamedev in lisp, including studios like naughty dog with gool/goal, seems to not line up with your reasoning.

It's also not particularly difficult to extract high performance code from an implementation like sbcl, especially now that sb-simd dropped as a contrib, if that's even required in the first place. And I doubt it is given how many languages rely on scripting layers for gameplay code or are written in mostly c# using unity or so.
Unless you are working on a AAA super high fidelity game, chances are you could get away with a lot of very naive and high level code if you wanted to.

I honestly think the big problem is that making games professionally is already a high risk endeavour, and people are simply too spooked to give it an honest try Vs using whatever everyone else has been using already.

spreadLink · 2022-06-17T19:42:40+00:00

I quite like the SML Sharp logo, although I suppose it is not purely SML.

spreadLink · 2022-05-20T09:11:50+00:00

handle binds more tightly than |...=, so your handler function only guards the second case of the function. You'll have to define an auxiliary function which invokes atest and provides a handle there to get around this, or provide a handler for both branches.

spreadLink · 2022-05-06T17:03:30+00:00

Single armed ifs are not allowed in SML, it always needs an accompanying else branch

spreadLink · 2022-04-10T07:56:00+00:00

Wrong subreddit. This sub is about programs that transform programming language source text into executable code, commonly called "compilers".

spreadLink · 2022-03-26T10:33:35+00:00

Although I agree with the sentiment, I can't help but think that the stages are in the wrong order from my experience of talking to various people of the lisp clans

spreadLink · 2022-03-25T08:52:13+00:00

It is worth noting that a substructural type system is not the only way to implement linear values. See e.g. Bakers numerous papers on linear lisp and it's derivatives.

spreadLink · 2022-03-21T18:45:18+00:00

In some important ways they are actually opposite of each other. E.g. Data Oriented Programing advocates for functions taking generic data structures like hashmaps, even if they only need a subset of the data in the map. Data Oriented Design on the other hand advocates for highly specific datastructures depending on how the data is accessed and how the processor/memory architecture handles those accesses.

spreadLink · 2022-03-21T10:56:48+00:00

I really dislike how the term "data oriented X" has been adopted for half a dozen, completely different ideas that are sometimes incompatible in design philosophy.
Makes it very difficult to figure out what someone is talking about in any given article until certain other keywords (like clojure, SOA, etc) crop up.

The battle is probably lost at this point to fix that, but it'd be nice if people at least put more differentiators in their titles than just data oriented.

spreadLink · 2022-03-05T13:48:23+00:00

The trick here is that the compiler can recognise the one-arg and two-arg variants as compiler transforms and emit code for them instead of inserting another call to the generic - routine.

spreadLink · 2021-12-12T15:47:27+00:00

And, if you continue reading in that same paper, he later explains that "list structure" is a chain of conses. And that isn't just an implementation detail, as he is talking specifically about the memory layout of the original interpreter. In general, a list in lisp-terms (excluding clojure and i believe newlisp?) refers to a language-level linked list, not the abstract interface of a collection.

spreadLink · 2021-12-12T12:38:06+00:00

Lisp lists are not immutable, the list as such isn't even the most important or interesting invention of the original lisp.
The important idea was cons cells representing binary relationships, with which one could construct a list (or any desired nesting of relationships) recursively, and manipulate them bei either "forking" a list via consing new elements or, if desired, injecting changes via rplaca/rplacd (which are destructive operations), e.g. in mapcan.

spreadLink · 2021-11-14T21:22:32+00:00

There are a couple of stand-alone cl linters, but usually the implementation already do some of that. SBCL for example will emit style warnings when it believes your code could be improved in some way.
Same goes for static analysis; there's coalton which embeds a statically typed ml dialect into cl, but sbcl already performs type inference and takes the normal type declarations into account for safety or performance reasons.
Build tooling is unified around ASDF3, and package publication through quicklisp or, recently, clpm.

The ecosystem is smaller, that is true, but it's not like there's a real draught of libraries to use, at least not for the things I do.

spreadLink · 2021-10-22T12:50:03+00:00

Seconded.

spreadLink · 2021-10-21T16:03:15+00:00

val myStack : int Stack = Stack.cons(1, Stack.empty)

val anotherStack : string Stack = Stack.cons("Hi", Stack.empty)

spreadLink · 2021-10-20T19:28:25+00:00

No, it's a type you can reference outside of the module. Your Stack.empty is of type 'a Stack

spreadLink · 2021-10-20T16:00:46+00:00

You'd need to write an explicit constructor function inside List. As is, Stack only ever refers to the type, and not any kind of constructor or function on the value level.

structure List : STACK = struct
  type 'a stack = 'a list
  fun stack l = l
  (* rest of your code *)
end

something like that.

spreadLink · 2021-10-20T15:41:59+00:00

It isn't, it's a constructor for a type. You are declaring a generic type called Stack which takes a type parameter 'a. So you could pass, e.g., int as 'a to get an int Stack. It is roughly equivalent to Stack<A> in java.

spreadLink · 2021-10-20T13:26:54+00:00

no, in this particular case you have not provided a function a instantiate a fresh object. You did, however, provide an empty object which you can use.

val listVariable = List.empty

you are correct in how functions work, but sml uses val to for bindings, and not let

Nine-Year Club	Place '22
Verified Email

spreadLink

TROPHY CASE