jfecher

9 ms·

1.
by jfecher 3mo ago
Creator of Ante here, passing `Rc<T>` as `&T` or `&Rc<T>` is a somewhat standard practice Ante inherits from Rust and C++ here. As for cycles, `Rc t` in Ante isn't magic and when used in cycles it will leak. Ante do
2.
by jfecher 3mo ago
Most uses of `uniq` in the article aren't necessary and are just included for explicitness. Anywhere a `uniq` ref is required but you only have a `mut` ref, Ante will convert it to a `local uniq` ref with the various rules required whi
3.
by jfecher 3mo ago
What would your ideal version look like? I recommend reading the C++ or Rust equivalent code in the article. I like the example because it is copied 1:1 with example code from a textbook with only some keywords changed and a Copy constraint
4.
by jfecher 3mo ago
Creator of Ante here. It's just a term I made up for mutation which does not change the "shape" of data in a way that can invalidate any of that data. Mutating a struct or tuple field, even if nested, is stable for example, b
5.
by jfecher 3mo ago
Creator of Ante here, Ante inherits Rust's Send/Sync for thread-safety. `mut` refs and `Rc` which provides shared mutability don't implement either and thus can't be shared across threads. So shared mutability is only wi
6.
Safe Aliasable Mutability via Stable References in Ante(antelang.org)
1 points by jfecher 1y ago|0 comments
7.
by jfecher 1y ago
> I'm actually hoping to find a way to blend Nick's approach seamlessly with reference counting (preferably without risking panics or deadlocks) to get the best of both worlds, so that we can consider it for Mojo. I consider th
8.
Stable, Mutable References (PL Design)(antelang.org)
2 points by jfecher 1y ago|0 comments
9.
by jfecher 1y ago
Right, compared to explicitly passing the parameter, with effects: - You wouldn't have to edit the body of the function to thread through the parameter. - The `can Use Strings` part can be inferred (and in Ante's case, it is my go
10.
by jfecher 1y ago
> As I understand it, AE on low level is implemented as a longjmp instruction with register handling (so you can resume). Not quite. setjmp/lonjmp as they exist in C at least can jump up the call stack but not back down. I mention t
11.
by jfecher 1y ago
If the database effect wrote to a file it'd require the `IO` effect and code using it would need that effect as well. A compiler can generally show a function to be free of most side effects if it uses no effects. The exceptions to thi
12.
by jfecher 1y ago
Developer of Ante here. Functions in languages with effect systems are usually effect polymorphic. You can see the example in the article of a polymorphic map function which accepts functions performing any effect(s) including no effect(s).
13.
by jfecher 1y ago
Author of Ante here - it actually already has an (extremely basic) LSP. Tooling more or less required for new languages out of the gate these days and I'm eyeing the debugging experience too to see if I can get replayability at least i
14.
Why Algebraic Effects?(antelang.org)
3 points by jfecher 1y ago|0 comments
15.
by jfecher 3y ago
Ante is still mostly unusable unfortunately! Ownership & Borrowing were a relatively recent change and I've still yet to implement them. Algebraic effects are also still in progress in a dev branch and won't be merged for some
16.
by jfecher 3y ago
Hi, author here! If anyone's curious, here's how ante addresses these issues: - It causes memory unsafety: Ante's `shared` references prevent memory unsafety by preventing projecting them into "shape-unstable" types
17.
Programming Language Design: Safe, Shared Mutability with Unboxed Types(antelang.org)
11 points by jfecher 3y ago|0 comments
18.
Achieving Safe, Aliasable Mutability with Unboxed Types(antelang.org)
1 points by jfecher 3y ago|0 comments
19.
by jfecher 4y ago
Hi! An uninterpreted function is one where the only thing we can assume about it is that `(x = y) => (f x = f y)`. That is if we give it the same input, we should get the same result out. In the context of refinement types this can be us
20.
by jfecher 4y ago
C can sometimes be an easier target since you don't have to learn LLVM's API. C is also more portable than llvm since there is a greater variety of C compilers for a greater variety of architectures than llvm targets.
21.
by jfecher 4y ago
Ack, my apologies, I didn't intend to be so inflammatory! If memory serves AFL was one of the first schemes (or perhaps the first?) to abandon the stack discipline to provide better inference in quite a few cases compared to TT. I reme
22.
by jfecher 4y ago
This is definitely an issue, but isn't one I run into often. Just like if I'm pasting code in rust I need to make sure it is inside or outside an if statement, I likewise need to ensure pasted code in ante is inside/outside t
23.
by jfecher 4y ago
Agreed. Other whitespace sensitive languages like Haskell, F#, and Ante handle multiline lambdas just fine
24.
by jfecher 4y ago
Lifetime inference originates from region inference which is actually completely unrelated to linear/affine/uniqueness typing. Uniqueness typing can definitely complement lifetime inference, but isn't really generalizeable to
25.
by jfecher 4y ago
My definition of low level is no tracing GC, values are unboxed by default, and users still have control to do low level things (raw pointers, other unsafe operations) when needed, even if it is not the default.
26.
by jfecher 4y ago
Correct, a key goal is to have no explicit region/lifetime annotations. There have been several papers on region inference after the originals by Tofte & Taplin, all attempting to refine the original analysis by inferring shorter l
27.
by jfecher 4y ago
This is definitely an interesting thought. My thinking is that "the fun stuff" tends to help make the language more functional, so removing it you are left with a more imperative language resembling a C clone with traits and type
28.
by jfecher 4y ago
Author here, thank you for your interest! There are definitely a lot of small design decisions that add up in language design, from using `|` for match cases to avoid double-indentation, to the use of pairs over tuples, to how methods are r
29.
by jfecher 4y ago
More or less, yes. I may later change it to some type like `Interpolated env` to represent a lazily interpreted string that interpolates the types in env. So "${1u8} and ${2}" would be typed as Interpolated (u8, i32). I'd lik
30.
by jfecher 4y ago
(1): No support, some monad or early-error-return sugar used to be considered but effects cover most of the usecases of monads and are easier to use so I plan on emphasizing them. As for arrows, I have to say here that I've actually ne

More ›