Hacker Newsnew | past | comments | ask | show | jobs | submitlogin

> The comptime feature is probably the most exciting thing I've seen in a while

Just please do not make the mistake of believing that it is unique to Zig. Factor brings the best of Forth and Lisp together, so meta-programming or extending the language is possible quite easily, for example. You could extend the syntax or add constructs pretty easily, and so forth. Anyways, an example can be found here: https://rosettacode.org/wiki/Compile-time_calculation#Factor but this barely scratches the surface. It does not mention `<< ... >>` which evaluates some code at parse time. You can execute code before the words in a source file are compiled.

https://docs.factorcode.org/content/article-literals.html

https://docs.factorcode.org/content/article-syntax-literals....

https://docs.factorcode.org/content/article-syntax-immediate...

https://docs.factorcode.org/content/word-flags{,literals.htm...

I remember when I did something like:

  SYMBOL: aligned-16-char

  <<
  : 16-byte-alignment ( c-type -- c-type )
      16 >>align 16 >>align-first ;

  char lookup-c-type clone 16-byte-alignment \ aligned-16-char typedef
  >>
when I was working on some binding.

You could use it in a struct like:

  STRUCT: foo
    { bar aligned-16-char[16] } ;
Or something like this is pretty typical (when writing bindings/ffi):

  << "libotr" {
      { [ os windows? ] [ "libotr.dll" ] }
      { [ os macosx? ] [ "libotr.dylib" ] }
      { [ os unix? ] [ "libotr.so" ] }
  } cond cdecl add-library >>
Those are just some examples, but it is pretty powerful. It supports (and encourages) interactive development. Profiling and debugging is a breeze and highly detailed and useful, you can easily disassemble words (functions), you can get a list of how many times malloc has been called in some circumstances, there is runtime code reloading (a vocabulary that implements automatic reloading of changed source files[1]), and so on. And on top of all this, you can compile your stuff to an executable that is less than 4 MB!

And of course you do not have to do stack shuffling at all, you can easily use locals which is useful for math equations and whatnot. Plus did you know that the Factor compiler supports advanced compiler optimizations that take advantage of the type information it can glean from source code? The typed vocabulary (yes, it is not part of the language, but implemented as a vocab) provides syntax that allows words to provide checked type information about their inputs and outputs and improve the performance of compiled code.

I would like to repeat because if this was not the case, I would have never bothered with it: you can create a single executable file that is less than 4 MB of size if you wish so! Of course it encourages interactive development, but still, it is great to have an optimizing compiler that can do all this easily. And mind you, this part is also written in Factor itself and is available as a vocabulary (vocab).

[1] There is a vocabulary named io.monitors and loaded source files across all vocabulary roots are monitored for changes. You can read more about it here: https://docs.factorcode.org/content/article-vocabs.refresh.h...

---

So all in all, I think Factor is great. I was shocked at how modern (and how many) libraries it has, especially considering only a handful of people have been working on it. Slava Pestov created the language, and some people joined him later on. If you want to learn more about it, start here: https://concatenative.org/wiki/view/Factor. There are videos, there are papers, there are lots of resources to get started. :) The language misses a couple of things, but it is being worked on.




> The comptime feature is probably the most exciting thing I've seen in a while

Also if comptime is simply compile time evaluation / execution, C++ has it with constexpr and templates.

Nim has this too I think.

Though judging by your comment not as powerful as Factor (I'm not familiar with it) extending syntax etc.

circle C++ probably gets closer: https://www.circle-lang.org/


> Just please do not make the mistake of believing that it is unique to Zig. Factor brings the best of Forth and Lisp together...

What is unique to Zig is that it has these features without bringing together "the best of Forth and Lisp". Sometimes, just being pedestrian is a virtue.


But comptime is kind of LISP's unique feature, it's just called macros.

EDIT: In fairness, Zig's presentation is pretty likeable. You can do a comptime expression pretty trivially in LISP, a comptime parameter or block would require actual effort.


No. There is a real difference between staged computation of the type that zig has and macros in common lisp, scheme/rust have (so much for lisp's uniqueness BTW). In common lisp you can do completely arbitrary computation at compile- (or read-)time in zig you cannot and crucially you are also not responsible for manually ordering the "stages". E.g. in common lisp you have use eval-when to make sure that stuff is available at the right phase, whereas zig works out the dependency for you.


Can you please provide an example of Zig "working out the dependency"? I'm struggling to make sense of your comment.


I could write a concrete example that will work in zig and fail in common lisp, but maybe this link is enough?

https://ziglang.org/#Order-independent-top-level-declaration...


Oh, so is the point that in Zig, functions with comptime parameters are more or less identical to regular functions in that regard?


Exactly. You can also use non-comptime functions in comptime, if it avoids certain types of stateful behaviour.


An example of this in the Zig math tests, where it tests calling the same function at both comptime and runtime: https://github.com/ziglang/zig/blob/33c4ad7f3a79aad5d7ea481a...


In common-lisp you could do something equivalent, but you'd have to wrap the definitions you want to be able at both compile and and run time in eval-when.




Consider applying for YC's Fall 2025 batch! Applications are open till Aug 4

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: