<infinisil>
I personally never saw any need for a "tell" command, but yeah that might be something to implement
<infinisil>
And I also plan to allow definitions with something like !who
<infinisil>
(but in a fancy and flexible way :))
<srk>
tell is usefull for some people who don't use bouncers
<srk>
but factoids are the real deal imho
<infinisil>
Oh yeah, actually I just couldve used this recently in #nixos..
<infinisil>
ye
<srk>
extremely useful for navigating larger ecosystems
<infinisil>
srk: The concatenation it can do is special, is it useful?
<srk>
which is why I wanted to do something similar for lambdabot
<srk>
concatenation? you mean 'is also'?
<infinisil>
yeah
<srk>
that's quite nice, like +=
<infinisil>
What is it used for?
<srk>
well it will add more meanings to the fact
<srk>
like: > hydra is hydra.nixos.org
<infinisil>
I've never seen the need to add more meanings to it, just to refine the old meaning
<srk>
> hydra is also a creature
<{^_^}>
undefined variable 'is' at (string):154:7
<srk>
hydra? would output both
<infinisil>
I mean, yeah it can be done, but it doesn't seem terribly useful :P
<srk>
true. I'm more interested in keeping the fact database intact for a long time :D
<srk>
as it is quite valuable
<srk>
not sure how you handle that
<infinisil>
That is something to improve for my bot.. Currently anybody can delete/change everything
<srk>
acid-state? :D
<infinisil>
And I'll have to load the old state from a backup to restore stuff
<infinisil>
acid-state?
<srk>
I see
<srk>
acid-state is awesome!
<srk>
!hackage acid-state
* infinisil
checks that out
<infinisil>
Ohh
<infinisil>
That sounds interesting
<srk>
basically in memory database, used by hackage as well
<srk>
whole hackage runs on it, modules using their own small state
<srk>
nice thing is that you can lay out your database as you like.. even Int would work
<srk>
[Int] as well.. you got the point :D
<infinisil>
Meh it's in IO though, couldn't this be doable with just STM?
<srk>
possibly, this dumps to disk automatically, you would have to do your own checkpointing with STM
<srk>
nice thing is that with safecopy you can even create migrations
<infinisil>
Ohhh??!
<infinisil>
I am just in a dilemma regarding migrations
* infinisil
checks out safecopy
<srk>
^^ :D
<srk>
I'm gonna try writing something like hydra-queue-runner in haskell..
<srk>
stm ftw
<infinisil>
srk: Hmm, it doesn't use higher kinded stuff as I'd hoped though
<infinisil>
Yes STM is awesome
<srk>
acid-state and safecopy is nice but a bit obscure, for some stuff I'm using persistant and esqueletto
<srk>
*persitent
<srk>
think for CI, SQL might be better option than in memory DB
<infinisil>
srk: Here's a recent experiment in idris which would perfectly encapsulate migrations between types, with minimal code and maximal safety, and it doesn't need any serialization inbetween, migrations are just a function oldtype -> newtype
<infinisil>
That would require some serious type-level fuckery in Haskell though..
<srk>
indeed
<infinisil>
srk: Hmm, so when I use a database, I would always get to just have a single type for the latest version, and put the migrations in the schema, and not have to worry about it?
<srk>
right, not sure if there are frameworks to handle migrations for you tho
<srk>
like alembic
<srk>
gonna check again, been a while till I've researched that
<infinisil>
I guess I'll try acid-state first, sounds really cool
<srk>
yeah
<infinisil>
That can also handle undoing things?
<infinisil>
With these rollbacks
<infinisil>
OR checkpoints
<srk>
looks like it
<srk>
I would expect it to run migrations in transaction as well
<infinisil>
Whoa and it even has a server-client thing
<srk>
that's mad, but easy when you have it structured like that - just send Updates to remotes :D
<infinisil>
srk: So one thing I don't think is possible with acid-state, which I'd love to have is:
<infinisil>
Not require a directory for each state, but to combine multiple states into a bigger type and use that instead
<infinisil>
E.g. with my nixbot it would be awesome if I could have a per-user plugin, which stores karma for every user via a single Int, detached from everything else
<srk>
if you structure your database as single type containing all other states
<srk>
it would do that
<srk>
but it also allows you to have multiple databases for each of them (what hackage does for plugins)
<infinisil>
Hmm..
<srk>
each plugin has its own state which makes it easy to load/unload them I guess
<infinisil>
The problem is again with types: If I have a list [Plugin] and each of them can have a different state type, then I can't just automatically put it into a combined type
<infinisil>
I'll need to write that combined type manually to handle each plugin
<srk>
yeah, or you would end up with similar structure like hackage - typeclasses with plugin_init, plugin_save..
<infinisil>
Yeah..
<srk>
which is nice but feels like too much boilerplate
<infinisil>
Damnit, I might just try to write something like acid-state and safe-copy in idris, I need muh type safety and composability
<srk>
:D
<srk>
sounds cool
<infinisil>
The experiment i have there is already rather promising
<srk>
want to try idris some day
<srk>
too much haskell going on :D
<infinisil>
Have also been coding a lot of haskell lately, almost no idris
<srk>
you do any coq possibly?
<infinisil>
That is actually the only thing I ever coded in Idris, like something to actually do something useful at least
<infinisil>
Nope
<srk>
hehe
<srk>
it took me a while to be able to code useful stuff in haskell too :D
<srk>
still feels like lots of pieces are missing - for example I've spent few weeks implementing better network status library recently on top of rtnetlink-hs
<infinisil>
I dabbed in trivial examples from LYAH for a long time until I finally got a good idea and implemented the first useful thing in haskell
<srk>
as the original network-info would return link local ipv6 address /o\
<infinisil>
Is that something bad?
<srk>
well, yes
<srk>
if your goal is to listen on an actually useful adrress :D
<infinisil>
I see, that api seems rather safe, with the Destroy classes and stuff