2023-09-17 06:31:38 <vms14       > :O
2023-09-17 06:45:45 <vms14       > about the error handlers, it can end being useful cause they can return something on the stack and execution should continue
2023-09-17 06:47:06 <vms14       > for example they could take input from the user if an argument was wrong and push it on the stack
2023-09-17 06:47:26 <vms14       > execution should resume after the error word
2023-09-17 06:48:19 <vms14       > and an unhandler error should terminate the program
2023-09-17 06:48:27 <vms14       > unhandled*
2023-09-17 06:48:43 <vms14       > at least looks much better than just printing an error
2023-09-17 06:49:58 <vms14       > and you have a return stack, so you can even play more tricks
2023-09-17 11:32:06 <KipIngram   > Yeah, I guess you could try to have an exception handler "correct" a bad situation.  However, in the vast majority of cases the error occurs because you did something wrong - such a handler would have to be able to figure out "what you really intended" and that doesn't strike me as very easy.
2023-09-17 11:32:37 <KipIngram   > I'm content to just do what's necessary to keep the system from crashing - I fail gracefully and put things back as they were to start with so I can try again.
2023-09-17 11:33:07 <KipIngram   > That way I don't have to fret over "what part of my input line ran and what part didn't?"
2023-09-17 11:33:28 <KipIngram   > If there's an error - none of ran.  Clean and simple.
2023-09-17 11:33:34 <KipIngram   > And well-defined.
2023-09-17 11:41:12 <KipIngram   > Bayes theorem questions sure are popular on Quora.  Always seem like someone's homework problem.
2023-09-17 12:26:55 <KipIngram   > What???
2023-09-17 12:26:57 <KipIngram   > https://www.youtube.com/watch?v=94mV7Fmbx88
2023-09-17 12:27:41 <thrig       > probably for folks trying to get into data science or AI
2023-09-17 12:39:50 <KipIngram   > I just find it fascinating that Pythagorean triples and the Fibonacci sequence are related.  Numbers are just so cool.
2023-09-17 13:07:22 <gordonjcp   > KipIngram: yeah it blows my mind how often the value of sin(pi) crops up in maths
2023-09-17 13:09:12 <thrig       > at least they put beangate behind them
2023-09-17 13:24:56 <Zarutian_iPad> beangate?
2023-09-17 13:28:34 <thrig       > "Pythagoras's Belief That Beans Are Human May Have Killed Him", etc
2023-09-17 13:43:16 <gordonjcp   > thrig: serious?
2023-09-17 13:47:13 <thrig       > https://www.britannica.com/science/Pythagoreanism etc
2023-09-17 13:53:03 <gordonjcp   > weird
2023-09-17 13:53:09 <gordonjcp   > oh well, the maths still works out
2023-09-17 14:42:14 <vms14       > seems to work
2023-09-17 14:42:23 <vms14       > (oh(my(cat"is")very)"nice")   it can read this
2023-09-17 14:43:41 <vms14       > it seems able to read them with any combination of spaces or lack of them
2023-09-17 14:44:26 <vms14       > and for what the interpreter knows, ( and " are just a word
2023-09-17 14:45:37 <vms14       > ((( will be read as three separate words
2023-09-17 14:46:13 <vms14       > actually the first ( will trigger the reading of the other and the other the last one
2023-09-17 14:46:46 <vms14       > i never got used to the " strings"
2023-09-17 14:47:00 <vms14       > i always forget the space and i dislike it a lot
2023-09-17 14:47:20 <vms14       > now i'm happy
2023-09-17 15:00:38 <veltas      > lisp
2023-09-17 15:00:57 <veltas      > I think you just want a lisp
2023-09-17 15:02:43 <vms14       > yes
2023-09-17 15:03:16 <vms14       > my lang is becoming a lisp gradually
2023-09-17 15:03:38 <vms14       > it was never a forth :/
2023-09-17 15:03:59 <vms14       > but every time it gets closer and closer to lisp
2023-09-17 15:04:53 <vms14       > from the start it used lists as code, then quote and quasiquote, then lexical scope and closures
2023-09-17 15:05:07 <vms14       > now it can read s-expressions properly
2023-09-17 15:05:40 <vms14       > just need apply and eval
2023-09-17 15:09:45 <vms14       > it's weird to see how i made a path from forth to lisp
2023-09-17 16:02:12 <KipIngram   > You made a path to lisp while chatting in a Forth channel.  :-)
2023-09-17 16:03:33 <KipIngram   > It's kind of fun thinking about how you might implement lisp in Forth.  Hint: ) does all the heavy lifting.
2023-09-17 16:04:16 <KipIngram   > ( just says "open a new list" (like on a stack of lists - ( would tell you to push an empty list onto the stack.
2023-09-17 16:04:31 <KipIngram   > All the items other than ( and ) would have you append to that list.
2023-09-17 16:04:48 <KipIngram   > And finally ) would "process" the top list on the stack, leaving the result as an "item."
2023-09-17 16:06:07 <vms14       > in my case ( reads by "words" and if it finds another (, a : or a "  it will execute that word
2023-09-17 16:06:50 <KipIngram   > Yeah, that's the recursive version of what I just said, I think.
2023-09-17 16:06:59 <KipIngram   > recursion vs. iteration.
2023-09-17 16:07:21 <vms14       > : does the same, but it makes a new environment for the new word and sets it as the current environment
2023-09-17 16:07:23 <KipIngram   > Or something along those lines.
2023-09-17 16:07:55 <vms14       > so if another : is executed, it will be created inside the other : automagically
2023-09-17 16:07:56 <KipIngram   > Yeah, that's one place where your setup deviates quite a lot from Forth.  In most Forth's, : just makes a dictionary entry and changes STATE.
2023-09-17 16:08:30 <KipIngram   > For me a second : does exactly what the first one did - just makes a header and points it at HERE.
2023-09-17 16:08:48 <KipIngram   > No differences at all.
2023-09-17 16:08:59 <vms14       > KipIngram: your ; can be grouped? like ;;
2023-09-17 16:09:02 <lilo_booter > my : works in the same way as vms14's - so the execution of the word creates the inner words
2023-09-17 16:09:09 <vms14       > or it was a different kind of ;
2023-09-17 16:09:13 <KipIngram   > vms14; Don't think of ;; that way.
2023-09-17 16:09:19 <KipIngram   > ;; is a word, of its very own.
2023-09-17 16:09:28 <KipIngram   > It just happens to return two levels instead of one level.
2023-09-17 16:09:34 <vms14       > hmm
2023-09-17 16:09:43 <KipIngram   > The pattern ; vs. ;; is just a naming convention.
2023-09-17 16:09:52 <KipIngram   > I don't have ;;; or ;;;; etc.
2023-09-17 16:10:14 <vms14       > i can make them be together like ;;;  they would be recognized as three words
2023-09-17 16:10:14 <KipIngram   > The compiler doesn't in any way treat ;; as ; ;
2023-09-17 16:10:37 <KipIngram   > Yeah, because your : is looking for the next ;
2023-09-17 16:10:41 <KipIngram   > Makes sense.
2023-09-17 16:11:28 <vms14       > it reads by words, but i can hook the ; to the reader so it does the same as it does with ( ) and "
2023-09-17 16:11:28 <KipIngram   > When I have : nested, the inner one sets STATE=1 just like the outer one does, but since it was already 1 it doesn't matter.
2023-09-17 16:12:36 <KipIngram   > In particular, when I nest : items, it doesn't create any kind of "nested" dictionary structure.  No "scope" funny business.
2023-09-17 16:12:42 <KipIngram   > Just makes another name in the dictionary.
2023-09-17 16:13:32 <KipIngram   > I do have those .: words, and generally they are not visible later, but to achieve that I explicitly remove them from the dictionary when I'm ready to.
2023-09-17 16:18:08 <vms14       > in my case ; is not even a word
2023-09-17 16:18:27 <vms14       > it's just a token for :
2023-09-17 16:18:58 <vms14       > same for )
2023-09-17 16:19:42 <KipIngram   > Right.  Just delimiters.
2023-09-17 16:20:29 <vms14       > the first times i tried to implement ( and ) i did push tokens on the stack xD
2023-09-17 16:20:56 <vms14       > i thought it would be cool cause i could manipulate them and alike
2023-09-17 16:21:16 <vms14       > but it sucked so much cause they got in the way when executing words
2023-09-17 16:22:10 <KipIngram   > So, in normal Lisp, if I had something like this:
2023-09-17 16:22:17 <vms14       > i tried once to count how many elements are pushed since i execute the list start delimiter
2023-09-17 16:22:25 <KipIngram   > ((...explained below...) 3 4 )
2023-09-17 16:22:39 <KipIngram   > And ...explained below... resulted in '+', would that yield 7?
2023-09-17 16:22:56 <vms14       > an error
2023-09-17 16:22:59 <KipIngram   > Or rather (...explained below...) results in '+'
2023-09-17 16:23:08 <vms14       > ah, it should work
2023-09-17 16:23:13 <vms14       > let me check
2023-09-17 16:23:16 <KipIngram   > Can you "compute operators" like that?
2023-09-17 16:23:30 <vms14       > it depends on what explained below is
2023-09-17 16:23:44 <KipIngram   > Anything that produces '+'
2023-09-17 16:23:47 <vms14       > () is a function call in lisp unless it's quoted
2023-09-17 16:24:12 <vms14       > but you can for example call a funtion that returns another
2023-09-17 16:24:39 <vms14       > ((find-fun "something") something args)
2023-09-17 16:24:46 <vms14       > it should work
2023-09-17 16:25:53 <vms14       > ((lambda (x) x) 'oh)
2023-09-17 16:25:56 <KipIngram   > Ok - that's what I was asking.
2023-09-17 16:25:58 <vms14       > for example
2023-09-17 16:26:23 <vms14       > in scheme i guess you have to call apply or funcall
2023-09-17 16:26:23 <KipIngram   > That would work in the Forth implementation of it I described above.
2023-09-17 16:26:41 <vms14       > oh i guess in scheme also works the same
2023-09-17 16:27:39 <KipIngram   > It's not particularly hard to write Forth that processes infix arithmetic either.
2023-09-17 16:27:54 <vms14       > just call next
2023-09-17 16:28:00 <KipIngram   > And supporting normal precedence of operators is readily done too.
2023-09-17 16:28:38 <vms14       > i never saw how forth achieves metaprogramming
2023-09-17 16:29:08 <KipIngram   > What do you mean by metaprogramming?
2023-09-17 16:29:10 <vms14       > in my case i have lists as code, which makes it very easy
2023-09-17 16:29:19 <vms14       > KipIngram: code that generates code
2023-09-17 16:29:30 <vms14       > for example lisp macros
2023-09-17 16:29:39 <vms14       > i know forth does not need them
2023-09-17 16:29:43 <KipIngram   > "generating code" is just adding data to the end of the dictionary.
2023-09-17 16:29:53 <vms14       > they achieve the same goals in different ways
2023-09-17 16:30:09 <vms14       > right
2023-09-17 16:30:20 <vms14       > in forth is even more usual than in lisp
2023-09-17 16:30:31 <KipIngram   > I don't see why you think it would be hard?
2023-09-17 16:31:02 <vms14       > it's hard in other kind of languages because of their syntax
2023-09-17 16:31:07 <KipIngram   > For the most part that's what's done with STATE.  As you find words in the dictionary, if STATE=0 you execute them.  If STATE=1 you add them to the end of the dictionary.
2023-09-17 16:31:38 <vms14       > well in forth you have the definition opened
2023-09-17 16:31:46 <KipIngram   > When you come to ; it's an immediate word, which executes right away - it adds a return to the end of the dictionary and sets STATE=0.
2023-09-17 16:31:49 <vms14       > this does not usually happen in other langs
2023-09-17 16:32:00 <KipIngram   > Sure it does - it just happens at compile time.
2023-09-17 16:32:45 <KipIngram   > By the time you run a C program it's finished - can't add more code then.
2023-09-17 16:33:18 <thrig       > SBCL is a C program and can add more code
2023-09-17 16:33:26 <vms14       > :o
2023-09-17 16:33:28 <KipIngram   > But the C compiler does something very similar while it runs.  It starts with an empty buffer and as it processes your source it adds code to it.
2023-09-17 16:33:37 <vms14       > actually sbcl is mostly written in lisp
2023-09-17 16:33:51 <KipIngram   > Yeah, seems like that ought to be possible.
2023-09-17 20:40:44 <KipIngram   > Hah hah - I've been watching Mathologer videos.  He always wears a math pun/joke t-shirt for these videos.  In this video I'm watching now, the t-shirt says "25.8069 IS THE ROOT OF EVIL."
2023-09-17 23:27:21 <KipIngram   > Next t-shirt: "This Fibonacci joke is as bad as the last two you heard combined."