Ferocity Alternatives

ferocity reviews and mentions

• Java JEP 461: Stream Gatherers
  3 projects | news.ycombinator.com | 3 Nov 2023

  The advantage of the static import DSL is that it is more composable: anyone else can define operators that interoperate with my operators without the complexity of the scheme linked above not to mention more generality. This goes not just for the low level operators like "filter" that you might want to supplement but the many more operators you can write that are implemented out of mine.

  I prototyped an API that works in the same direction as streams by having something like

  https://paulhoule.github.io/pidove/apidocs/com/ontology2/pid...

  in that it wraps all Iterables returned by my methods and has not just the teardown facility but also all the operators attached as instance methods which lets you write the chaining style you ask for that I know is in demand.

  If I was going to go any further on pidove it would have involved more use of code generation and this system

  https://github.com/paulhoule/ferocity

  which was supposed to be a code generator for writing code generators, and it could code generate stubs that would let you write expression trees in Java as S-expressions and build them up into methods and either compile the code to real Java source code or execute the methods by evaluating the expression tree in place.

  Like common LISP you can write syntactic macros in that that metalanguage because an Expression> can be evaluated at compile time, one of quite a few concepts like "quoting" that I encountered in that spike.

  The idea was ferocity would get to the point where it synthesizes a more complete and perfect pidove.

• TypeScript please give us types
  10 projects | news.ycombinator.com | 7 Jul 2023

  but you can't have an overload that takes two differently parameterized expressions, this lets you write Java code in a lisp-like syntax that can be metaprogrammed on:

  https://github.com/paulhoule/ferocity/blob/main/ferocity-std...

  that project got me thinking a lot about the various ways types manifest in Java and I made the discovery that when you add Expression types you practically discover an extended type systems where there are many things that are implied by the existence of ordinary Java types.

• Overinspired?
  2 projects | news.ycombinator.com | 10 Mar 2023

  I find this alien to my point of view. On the other hand, my side projects aren't driven by FOMO but are more like the "special interests" of autistic people.

  Most of the time I have three side projects going on, maybe two of which are really getting the attention they deserve and one that is languishing. (See my profile to see about my current three.) Occasionally I get inspired to spend 1-4 weekends on some sudden inspiration, of which

  https://github.com/paulhoule/pidove

  came to completion but

  https://github.com/paulhoule/ferocity

  probably won't. The project I'm working the hardest on now is something that I was baffled that it didn't exist 18 years ago but felt compelled to do something out because of the Twitterinsanity last December and it turned out the technological conditions right now make it the perfect time to work on.

• Typed Lisp, a primer (2019)
  3 projects | news.ycombinator.com | 31 Jan 2023

  I have hacked off and on on this

  https://github.com/paulhoule/ferocity

  which lets you write extended Java in a lispy syntax. It generates stubs for the standard library and other packages you choose, unerasing types by putting them into method names. It works pretty well with IDEs but there are still problems w/ type erasure such that some kinds of type checking can't be done by the compiler working directly on the lispy Java, probably I wouldn't implement newer features such as pattern matching that are dependent on type inference to work, though lambda definitions are feasible if you give specific types.

  The 'extended' bit was almost discovered instead of invented in that it is pretty obvious that you need quote and eval functions such that you can write lispy Java programs that manipulate Java expressions. Said expressions can be evaled at runtime with a primitive interpreter or incorporated into classes that are compiled w/ Javac. The motivation of the thing was to demonstrate Java-embedded-in-Java (an ugly kind of homoiconicity) and implement syntactic macros from Java which I think that prototype proves is possible but there is a lot more to be done on it to be really useful. Enough has been implemented in it right now in that you can use it to write the code generator that builds stubs. It might be good for balls-to-the-walls metaprogramming in Java but I think many will think it combines all the worse features of Java and Lisp.

• Byte Magazine: Lisp
  1 project | news.ycombinator.com | 5 Aug 2022

  There is this project

  https://github.com/paulhoule/ferocity/

  which I might finish up when I'm done with the report I'm writing. It is possible to create Java expression trees with trees of static method calls that look a lot like S-expressions and stick them together into statements, methods and classes.

  You should be able to do the same tricks people do with LISP macros and it could work code generation miracles but it would have that "LISP curse" problem in spades.

  The plan is to generate a code generator that is sufficient to generate the full DSL implementation (ferocity0) and use that to generate the full implementation (ferocity.)

  I have some tests for ferocity0 writing .java files to get fed to javac and for ferocity0 running expression trees with a primitive interpreter. Already the type system is enriched over the type system because interpreted ferocity0 can handle Java expressions as a type at run time so you get issues like quoting and unquoting in LISP.

• What Happened to Lambda-the-Ultimate.org
  2 projects | news.ycombinator.com | 18 Apr 2022

  Internal or external?

  I think Java is just fine for internal DSLs, see

  https://www.jooq.org/

  I was also hacking on this project

  https://github.com/paulhoule/ferocity/

  which was about making Java homoiconic. Namely in ferocity you can write

     Expression literal = of("Hello World");

• The Number Guessing Game Written in YAML as Lisp Interpreted with Python
  1 project | news.ycombinator.com | 10 Feb 2022

  You could process that Expression in a few different ways, for instance you could evaluate the tree using reflection or you could turn the tree into source code and compile it with javac.

  Going down that path I found it was more about discovery rather than invention. That is, you will discover the issues that come up around quoting in LISP and develop some answers to them. Also for the exercise to be interesting at you will get into an execution model that is a bit bigger than the original language : for the metaprogramming to be fun at all you want to be able to write Expressions that manipulate Expressions so you end up introducing types that don't really exist in the base language. These are almost trivial to handle using the primitive interpreter style but could be more of a challenge to compile to source code.

  Some source code is here

  https://github.com/paulhoule/ferocity

  It's been a long time since I worked on it and I need to see if I have more notes explaining the plan behind it, but the idea was to develop "ferocity0" which was a version of the DSL that was good enough to build stubs for some of the language and a large part of the standard library, and then use code generation techniques to create "ferocity1" which would be like "ferocity0" but would cover 100% of the Java language.

  My current side project is being sidelined by supply chain problems so I might go back into that one.

• A note from our sponsor - WorkOS
  workos.com | 29 Apr 2024

  The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning. Learn more →