I'm a bit late to this, but it caught my eye.
The only common use case I have for mutating data structures in Clojure is
when storing state in a global map (similar to Om.Next), but I almost
always make them atomic to account for nondeterminism in the order
operations on them will finish. Woul
Both, actually. The algorithm incrementally builds a tree via simulation.
There's a step of traversing the current version of the tree to find a
leaf, which requires immutability, as I have to remember the path taken
(the path is generated via simulation, not by walking an existing tree
structu
Are you relying on the immutability of these structures, or are they
effectively always transient?
On Sun, Apr 23, 2017 at 11:02 AM Dave Dixon wrote:
> FWIW, the use-case I have essentially involves Monte Carlo simulations. So
> we start with a state (non-empty map), and then make a series of
> m
FWIW, the use-case I have essentially involves Monte Carlo simulations. So
we start with a state (non-empty map), and then make a series of
modifications to it. Various statistics are held in hash-maps keyed by the
state, so there's a lot of lookups and modifications in those maps.
That said, I
Sure, happy to elaborate. Bifurcan offers potential performance wins a few
different ways:
* We can use standard Java equality semantics, bypassing all the overhead
of the hash calculations and enhanced numeric equality checks (this can
lead to moderate performance gains)
* We can use a mutable d
Sounds great. If you have time, I'd certainly like to hear your thoughts on
the issues of equality semantics and transients, maybe I can ponder and
make some suggestions based on my target use-case.
On Tuesday, April 18, 2017 at 9:32:32 AM UTC-7, Zach Tellman wrote:
>
> To be clear, my intention
Looks cool! I'm going to mine this for ideas and potentially use it. FWIW
I've also been implementing some Java functional data structures for my
language design experiments.
If anyone is interested happy to share code, my own motivations were:
- I wanted decent persistent Lists, Sets, Maps for
To be clear, my intention was always to wrap the implementations in the
appropriate Clojure interfaces, and I don't believe that will cause much,
if any, of a performance hit (inlining is magic). However, there are some
real questions regarding how to expose non-standard equality semantics, and
wh
Stared at this a bit yesterday. Seems like if you want to leverage spec
while using bifurcan, then the bifurcan types need to have the Clojure
wrapper. The alternative appears to be re-implementing at least a large
subset of collection-related spec code, which is a lot to bite off. Also
tried u
What is the issue with wrapping in Clojure interfaces? Added overhead of
function calls?
I'm finding myself in the process of doing some of this, at least for
constructors. Also thinking of generating predicates/generators for use
with spec.
On Monday, March 27, 2017 at 9:51:46 AM UTC-7, Zach
I do a lot of work with data structures, so this, I think, would be useful
to me.
For the immutable data structures, it seems like they could be done as a
drop-in replacement for the Clojure built-ins. There are a couple new
functions for splitting and concatenating. I'd recommend following
prec
I think this would solve an issue I'm facing. I'm working on implementing
variations of Monte Carlo tree search for very large trees, with states and
actions represented by maps. There are several lookup tables indexed by
either state or state-action pairs. I haven't done any detailed
benchmark
Both the 'List' and 'Map' data structures in Bifurcan use innovative
approaches that were published after Clojure's original release [1] [2].
In the case of the immutable map, you get faster iteration and the
structural invariants allow for some clever stuff w.r.t. equality checks
and set operation
I'm not well versed enough in these data structures to know this without asking
(apologies if it's really obvious to some people): is there opportunity to
improve Clojure's built-in data structures with Bifurcan rather than trying to
wrap Bifurcan's structures in Clojure?
As an aside, I want
Benchmarks are available here, and the Clojure benchmarks make use of
transients wherever possible:
https://github.com/lacuna/bifurcan/blob/master/doc/benchmarks.md.
More generally, while transients are often used in practice to quickly
construct a read-only data structure, the more formal definit
> On Mar 27, 2017, at 09:51, Zach Tellman wrote:
>
> They also provide high-performance mutable variants of the data structure
> which share an API with their immutable cousins.
How does their performance compare to Clojure's transients? Transients are
slower than Java's native mutable collec
This is a slightly irregular announcement, because it's not for a Clojure
library. Rather, it's for a library written purely in
Java: https://github.com/lacuna/bifurcan.
This is a collection of mutable and immutable data structures, designed to
address some of my personal frustrations with wha
17 matches
Mail list logo