2023-10-04 00:00:05 <KipIngram   > I lay my headers out like this:
2023-10-04 00:00:30 <KipIngram   > <PFA  pointer> <CFA pointer> <link to prior word> <name count> <name>
2023-10-04 00:00:58 <KipIngram   > As I said, though, you can do this in many ways; it's a flexible concept.
2023-10-04 00:01:03 <seepel      > 
ACTION KipIngram: That is an awesome amount of info thank you! I think what I'm after is if there would be any gotchyas that I'm not thinking of. (I'm implementing this in WebAssembly if that's relevant)

2023-10-04 00:01:22 <KipIngram   > I don't see any show-stopper problems in your design.
2023-10-04 00:01:41 <KipIngram   > You have the name string "not in the middle" of the other fields, and that's good.
2023-10-04 00:01:50 <KipIngram   > One issue.
2023-10-04 00:02:05 <KipIngram   > forth normally uses "counted strings," which means a count byte followed by the string bytes.
2023-10-04 00:02:32 <KipIngram   > Your name fields are not laid out that way, so you won't be able to treat dictionary name fields using standard counted string words you use in your own definitions.
2023-10-04 00:02:34 <seepel      > 
ACTION Yeah, I'm kind of inverting and aligning it. But at this low level it makes all the math easier for me.

2023-10-04 00:02:40 <KipIngram   > You have <name bytes><count>.
2023-10-04 00:02:59 <KipIngram   > If you did all counted strings that way I suppose it could be made to work, but it's just unusual.
2023-10-04 00:03:53 <KipIngram   > would the definition data for a word immediately follow its header?
2023-10-04 00:04:02 <seepel      > Yeah that's my plan.
2023-10-04 00:04:06 <KipIngram   > That's how the oldest Forths did it.
2023-10-04 00:04:31 <KipIngram   > I keep my headers in a different section of RAM from my definition data, so I have a pointer to the definition data.  That's what I referred to as <PFA pointer> above.
2023-10-04 00:04:50 <seepel      > I was just about to ask. If I compare your header to Moving Forth would it be accurate to say that your headers are token threaded in his vernacular? https://www.bradrodriguez.com/papers/moving1.htm
2023-10-04 00:04:53 <KipIngram   > it's not that I'm right and you're wrong - it's just two different ways of doing it.  my way is slightly less space efficient.
2023-10-04 00:05:09 <KipIngram   > No, it's not a token threaded design.
2023-10-04 00:05:23 <KipIngram   > The definition data still looks like standard indirect threaded Forth.
2023-10-04 00:05:48 <KipIngram   > I just have it somewhere else and point to it, instead of having it "right there."
2023-10-04 00:05:49 <seepel      > 
ACTION Ahhh

2023-10-04 00:05:53 <KipIngram   > It's perfectly fine to have the definition "right there.'
2023-10-04 00:06:25 <KipIngram   > The only real advice I'd give you is to say put your name count byte before the character data, and move the name string to the end instead of the beginning.
2023-10-04 00:06:49 <KipIngram   > well, wait.
2023-10-04 00:06:59 <KipIngram   > That's not really a good idea if you're g oing to have the definitions right there.
2023-10-04 00:07:01 <KipIngram   > so scratch that.
2023-10-04 00:07:13 <KipIngram   > It's only a reasonably workable plan if you use a pointer like me.
2023-10-04 00:07:30 <KipIngram   > I'd still move the count byte to the front of the name, though - I think you'll be happier long term if you do that.
2023-10-04 00:07:40 <seepel      > I was kinda thinking to the left of the xt is an indeterminate amount of bytes + the link. then to the right of the xt is the code.
2023-10-04 00:08:34 <KipIngram   > Yes, depending on how you lay it out you might find you have to traverse the name.  In one direction you can use the count to jump over the name, but in the other direction you have to scan.
2023-10-04 00:09:22 <KipIngram   > I think you're going to have fun with this - building a Forth system is just a fun project.
2023-10-04 00:09:31 <seepel      > I'm already having a blast!
2023-10-04 00:09:34 <KipIngram   > And the rush you get when first begins to work - really nice.
2023-10-04 00:10:21 <KipIngram   > So let me explain why I put my definitions 'elsewhere.'
2023-10-04 00:10:35 <KipIngram   > By doing so, I can write something like this:
2023-10-04 00:10:41 <KipIngram   > : foo ...
2023-10-04 00:10:45 <KipIngram   > : bar ... ;
2023-10-04 00:10:45 <seepel      > 
ACTION I started by trying to hack on WAForth, but found that for my project I really wanted to be able to reset the instruction pointer so here I am :) https://github.com/remko/waforth

2023-10-04 00:10:52 <KipIngram   > Note the absence of a ; at the end of foo.
2023-10-04 00:11:04 <KipIngram   > When that's compiled, if I run foo, it will run both ... code sections.
2023-10-04 00:11:10 <KipIngram   > foo "falls through" into bar.
2023-10-04 00:11:20 <KipIngram   > So it lets me define multiple entry points to the same section of code.
2023-10-04 00:11:25 <seepel      > That sounds like something I want...
2023-10-04 00:11:26 <KipIngram   > The header of bar isn't sitting in the way.
2023-10-04 00:11:49 <KipIngram   > You could still support that feature, but you'd have to compile a jump at the end of foo to jump over the header.
2023-10-04 00:12:57 <KipIngram   > But separating headers from definitions does mean you have more RAM blocks to manage.
2023-10-04 00:13:07 <KipIngram   > And it does require that extra pointer in the headers.
2023-10-04 00:13:25 <seepel      > I'll be honest, that sounds annoying. I'm starting to like yours...
2023-10-04 00:13:29 <KipIngram   > I just felt the benefit was worth it.  that was just a personal preference though.
2023-10-04 00:13:33 <KipIngram   > Feel free to rip it off.
2023-10-04 00:13:46 <KipIngram   > It really originated here in this channel.
2023-10-04 00:13:55 <seepel      > I'm really  glad I asked :) Thank you for the help!
2023-10-04 00:14:07 <KipIngram   > I had a different one before and we talked about it here one day, and I just decided I liked the new layout better, so I ripped into my code and changed it.
2023-10-04 00:14:13 <KipIngram   > What tool are you using to develop?
2023-10-04 00:14:19 <seepel      > wat2wasm
2023-10-04 00:14:25 <KipIngram   > I've most recently used nasm.
2023-10-04 00:14:38 <seepel      > I'm just typing up the assembly
2023-10-04 00:14:38 <KipIngram   > Ok.  If it has a good macro facility you may be able to write macros to create your headers.
2023-10-04 00:14:44 <seepel      > No macros
2023-10-04 00:14:56 <seepel      > It's mildly annoying, but github copilot helps a lot
2023-10-04 00:15:13 <KipIngram   > Here's what a word definition looks like in my nasm source:
2023-10-04 00:15:15 <KipIngram   > ;;;  : interpret  find tasks 0=me exec me [
2023-10-04 00:15:16 <seepel      > It does the pointer arithmetic form me
2023-10-04 00:15:17 <KipIngram   >                 def     "interpret", interpret
2023-10-04 00:15:19 <KipIngram   >                 run     find, tasks, zeme, 16+do, exec, me, 28+do
2023-10-04 00:15:25 <KipIngram   > def is a macro.  It creates the dicionary entry.
2023-10-04 00:15:37 <KipIngram   > run is also a macro - it uses that list of labels to build the definition.
2023-10-04 00:16:28 <KipIngram   > Here's what a primitive definition looks like:
2023-10-04 00:16:30 <KipIngram   >                 code    "b>", bfrom
2023-10-04 00:16:32 <KipIngram   >                 decd    rrSP
2023-10-04 00:16:34 <KipIngram   >                 putd    rrSP, rrTOS
2023-10-04 00:16:36 <KipIngram   >                 mov     rrTOS, rrB
2023-10-04 00:16:38 <KipIngram   >                 next
2023-10-04 00:16:40 <KipIngram   > code is also a macro that creates a header.
2023-10-04 00:16:55 <KipIngram   > decd, putd, and next are macros too.
2023-10-04 00:17:13 <KipIngram   > But the lines after the "code" line you should just regard as assembly.
2023-10-04 00:19:18 <seepel      > I'm not sure you have any interest, but I went ahead and pushed what I have https://github.com/seepel/flea-scheme/blob/master/forth32.wat No comments or anything so maybe it doesn't even make sense ¯\_(ツ)_/¯
2023-10-04 00:20:09 <KipIngram   > I'll take a look at it tomorrow.
2023-10-04 00:20:56 <seepel      > Really only if you're interested, don't feel obligated. In any case, you've been so helpful, thanks again!
2023-10-04 00:21:00 <KipIngram   > I'm  planning a new system myself right now, that is going to be token-threaded and uses Chuck Moore's F18A processor as "inspiration."
2023-10-04 00:21:13 <KipIngram   > You're welcome - let us know how it's coming along.
2023-10-04 00:21:57 <KipIngram   > The F18A is documented here:
2023-10-04 00:21:59 <KipIngram   > https://www.greenarraychips.com/home/documents/greg/DB001-221113-F18A.pdf
2023-10-04 00:22:33 <seepel      > Oh you know what, I did briefly look at that a while back and then got to intimidated :)
2023-10-04 00:23:41 <KipIngram   > Sounds like you're starting out in a good way to me.
2023-10-04 00:23:54 <KipIngram   > I doubt it will be the last Forth you ever write.  :-)
2023-10-04 00:24:25 <KipIngram   > On the other hand, I'm hoping this one will be my last one.
2023-10-04 00:24:32 <KipIngram   > One that I'll hang onto and actually use.
2023-10-04 00:25:00 <KipIngram   > I've got a little microcontroller board, the MAX32655, that I want to put it on, and then use that for hobby electronics projects in the future.
2023-10-04 00:25:13 <KipIngram   > It's a tiny board and will be easy to solder ontO 'whole project boards'.
2023-10-04 00:40:03 <seepel      > Ahhh, now that I work through your header I see that the PFA is the back pointer
2023-10-04 00:40:11 <seepel      > Is that right?
2023-10-04 00:41:48 <KipIngram   > No, the PFA points off to the definition addresses.
2023-10-04 00:42:01 <KipIngram   > the CFA would point to the "docol" code, for a : definition.
2023-10-04 00:42:08 <KipIngram   > Did I leave out link?
2023-10-04 00:42:12 <seepel      > 
ACTION No

2023-10-04 00:42:50 <KipIngram   > <link to prior word> is the number of bytes back from its own address to the previous word's link address.
2023-10-04 00:43:05 <KipIngram   > So, it's a "relative" pointer.
2023-10-04 00:43:11 <seepel      > 
ACTION You had link<PFA  pointer> <CFA pointer> <link to prior word> <name count> <name>

2023-10-04 00:43:19 <KipIngram   > But the PFA and CFA pointers are addresses.
2023-10-04 00:44:03 <KipIngram   > So for a : definition, <CFA pointer> says "this is a colon definition," and <PFA pointer> says "and here are the definition details.
2023-10-04 00:46:16 <seepel      > I redid my diagram of what I thought an entry would look like with that header and this is what I came up with.
2023-10-04 00:46:36 <seepel      > https://www.irccloud.com/pastebin/GKf0RnbX/
2023-10-04 00:48:26 <KipIngram   > Yes, that looks like what my current system does.
2023-10-04 00:48:44 <KipIngram   > I've been quite happy with it.
2023-10-04 00:49:34 <KipIngram   > So those just "grow" in some region of RAM as you define new words.
2023-10-04 00:50:05 <KipIngram   > And in some other region your "implementations" (the spaces you actually store your variables in, your definitions, and so on) just grow.
2023-10-04 00:50:41 <KipIngram   > Older Forths use a variable named DP to point to the next free byte in RAM.  : HERE  DP @ ;
2023-10-04 00:50:59 <KipIngram   > I have to have two variables for that, since I have a "bodies" region and a "headers" region.
2023-10-04 00:51:07 <seepel      > Yeah, this seems great. Though I suppose ENTER should actually just be the CFA?
2023-10-04 00:51:43 <KipIngram   > I'm not sure what you mean by those ENTER items.
2023-10-04 00:52:26 <KipIngram   > That's the previous word?
2023-10-04 00:52:31 <seepel      > ENTER here is the same as DOCOL
2023-10-04 00:52:38 <KipIngram   > Ah.
2023-10-04 00:52:53 <seepel      > I think I picked that up from Moving Forth and I liked how it matched EXIT :)
2023-10-04 00:53:21 <KipIngram   > Well, if you separate headers and definitions, then the header region will just string the headers together.  just before PFA pointer would be the name bytes of the prior word.
2023-10-04 00:53:40 <KipIngram   > Maybe with a couple of bytes of padding - you probably should align the beginning of each header in some appropriate way.
2023-10-04 00:54:16 <KipIngram   > For a : definition, <CFA Pointer> would point to docol.
2023-10-04 00:55:45 <seepel      > That makes sense to me.
2023-10-04 00:58:00 <KipIngram   > So docol would push the instruction pointer to the return stack and load the instruction pointer with the value pointed to by <PFA pointer>
2023-10-04 00:58:33 <KipIngram   > What's your background, seepel?
2023-10-04 00:59:50 <seepel      > Oh gosh. I started as a High Energy Physicist, then went and built iOS apps, then went and built a low code platform, and now I'm building generative AI applications
2023-10-04 01:00:13 <KipIngram   > Ah, you sound like me in terms of moving around.
2023-10-04 01:00:25 <seepel      > I like learning new things :)
2023-10-04 01:00:37 <KipIngram   > It's a good trait.
2023-10-04 01:01:15 <KipIngram   > I'm an EE but I've worked in several different focus areas.
2023-10-04 01:01:56 <KipIngram   > Equipment for electronic manufacturing, seismic, down-hole oilwell tools, data storage, and university research.
2023-10-04 01:02:57 <KipIngram   > I love physics.
2023-10-04 01:03:15 <KipIngram   > Spend a good chunk of my time finding stuff to learn online in physics and math.
2023-10-04 01:05:57 <seepel      > What field of physics do you like to read about?
2023-10-04 01:08:53 <KipIngram   > Oh gosh.
2023-10-04 01:09:24 <KipIngram   > All over, really.  Interpretation issues in quantum mechanics is a perennial interest.  But really, so much of it.
2023-10-04 01:09:38 <KipIngram   > I just try to get "more."
2023-10-04 01:09:51 <KipIngram   > I'm quite fond of statistical mechanics.
2023-10-04 01:10:24 <KipIngram   > I think of it as a particularly "beautiful" process, watching the macroscopic thermo laws pop up out of treating molecules as an ensemble of little balls flying around.
2023-10-04 01:15:32 <KipIngram   > I also like cosmology, relativity, etc. - probably the "usual hit list."
2023-10-04 01:29:26 <seepel      > Hmm, turns out I'm still struggling. If the name is at the end of the dictionary entry, how can you implement CREATE?
2023-10-04 01:29:58 <seepel      > You need to know when the body ends so that you can write the name right?
2023-10-04 01:44:30 <KipIngram   > If you are separating headers and definitions, then they are in two completely fifferent RAM regions.
2023-10-04 01:44:50 <KipIngram   > If you're not, the body goes after the header, not before.
2023-10-04 01:47:47 <KipIngram   > Remember in a colon definition the name comes first, so you  make the header as soon as you see the word in the input stream.
2023-10-04 01:47:59 <KipIngram   > Then you move on to compiling the definition after.
2023-10-04 01:48:08 <seepel      > I see
2023-10-04 08:59:40 <veltas      > seepel: The name isn't visible until end because the header isn't linked into the word list until ; is executed
2023-10-04 09:00:27 <veltas      > See for example https://github.com/Veltas/Tebbi-Forth/blob/main/tebbi-forth.4th#L29
2023-10-04 09:02:06 <veltas      > Which is a chicken-and-egg way of writing   : ;   [COMPILE] EXIT  [COMPILE] [  CURRENT @ ! ; IMMEDIATE
2023-10-04 09:02:50 <veltas      > CURRENT @ ! sets the wordlist stored in CURRENT to point to the address on the stack, which is the header address produced by :
2023-10-04 09:36:57 <KipIngram   > That can vary depending on the system.  In my system it's immediately available.
2023-10-04 09:38:04 <KipIngram   > I believe in colorForth Chuck made it immediately visible as well; it's how he did looping.
2023-10-04 09:38:45 <KipIngram   > You can't do tail recursion unless it's visible (or you provided some other way).
2023-10-04 09:42:02 <KipIngram   > And in fact, if you want it to be invisible until ; is done, you have to deliberately write it that way - the "simplest default" is for it to be visible as soon as CREATE updates the pointer to the latest word.
2023-10-04 09:45:44 <crc         > my systems also make the name immediately visible
2023-10-04 09:47:33 <GeDaMo      > Do you have a way to refer to an earlier definition with the same name?
2023-10-04 09:47:47 <KipIngram   > seepel: Systems that don't have a word visible until its definition is complete usually do so by having what they call a "smudge" bit in the header.  CREATE will set that bit when it creates the header - it's only purpose is to make searches fail.  In those cases ; clears the bit.
2023-10-04 09:47:52 <KipIngram   > No.
2023-10-04 09:48:04 <KipIngram   > Unless you make an access word.
2023-10-04 09:48:09 <KipIngram   > : foo ... ;
2023-10-04 09:48:15 <KipIngram   > : bar  foo ;
2023-10-04 09:48:27 <KipIngram   > : foo ...another definition... ;
2023-10-04 09:48:48 <KipIngram   > Now foo will always run the second definition, but bar will still run the original one.
2023-10-04 09:49:49 <KipIngram   > And that's important to understand that - someone else that dropped by the other day felt that bar should switch to the new definition, but that's not how it works.
2023-10-04 09:50:26 <KipIngram   > The names are evaluated at compile time, and the finished definitions have no knowledge of what the NAMES were that were used to build them.
2023-10-04 09:50:30 <KipIngram   > They're just lists of addresses.
2023-10-04 09:53:11 <KipIngram   > GeDaMo: Word searches continue until they find a match and look no further, and they run in reverse chronological order in each vocabulary.
2023-10-04 09:53:30 <GeDaMo      > Yeah
2023-10-04 09:58:05 <crc         > GeDaMo: on my system, I'd define a quote & then attach a name afterwards (e.g., `[ ... name ... ] \name`)
2023-10-04 10:00:14 <KipIngram   > crc: does that quote leave a reference to the "code string" on the stack?
2023-10-04 10:00:24 <crc         > in the past I had `prior` (used as `prior name`) for this, but I dropped that a number of years ago
2023-10-04 10:01:02 <crc         > code string?
2023-10-04 10:01:50 <crc         > [ ... ] leaves a pointer to the compiled function; \name creates a new header for `name` and assigns it to point to the address from the stack
2023-10-04 10:33:23 <KipIngram   > That was what I was asking.  By "code string" I meant the definition you just compiled.
2023-10-04 10:33:53 <KipIngram   > Honestly doing it that way - caching the definition on the stack and then "storing" it somehow seems more "RPN-oriented" to me than the way we normally do it.
2023-10-04 10:34:34 <GeDaMo      > That's similar to POstscript
2023-10-04 10:36:53 <KipIngram   > And it also then puts you in a position to do... "other things" with your compiled definitions.  You could make a table of them, or whatever.
2023-10-04 10:38:45 <KipIngram   > is that definition created initially in its permanent location, or does the naming operation copy it somewhere?
2023-10-04 10:42:52 <crc         > it's created at its permanent location
2023-10-04 10:45:46 <crc         > (my system only supports absolute addressing, so I can't just copy the compiled code around)
2023-10-04 10:47:17 <KipIngram   > Gotcha.
2023-10-04 10:47:52 <KipIngram   > I think the new work I'm  planning will put me in a position to copy compiled code around, but only up until such time as there's an external reference to it.
2023-10-04 10:48:14 <KipIngram   > I don't think anything "internal to the definition" will nail it to a fixed spot.
2023-10-04 11:20:49 <KipIngram   > So I had some further thoughts about how to recognize vectors in a type-supporting system.
2023-10-04 11:21:05 <KipIngram   > In APL a vector is just a list of items: 1 2 3 would be a vector.
2023-10-04 11:21:26 <KipIngram   > In an RPN system we face how to tell the difference between that and three separate integers.
2023-10-04 11:21:52 <KipIngram   > it occurred to me that our RPN calculators deal with this same problem, except instead of numbers and vectors we're working with digits and numbers.
2023-10-04 11:21:58 <KipIngram   > And that's what the Enter key is for.
2023-10-04 11:22:07 <KipIngram   > "Stop adding digits to this number and start a new number."
2023-10-04 11:22:12 <KipIngram   > It's exactly the same problem>
2023-10-04 11:22:31 <KipIngram   > So it seems like the right  answer is to have some symbol that plays the role of "stack item separator."
2023-10-04 11:22:56 <KipIngram   > A function will end construction of a stack item, so you could think of this as some sort of "noop function.'
2023-10-04 11:23:26 <KipIngram   > APL uses ⋄ as an expression separator - it seemed like a reasonable candidate to me.
2023-10-04 11:24:12 <KipIngram   > The down side of doing it that way is that when you were entering a lot of numbers you'd need a lot of ⋄'s.
2023-10-04 11:24:32 <KipIngram   > Whereas if vectors used some sort of brackets, then numbers could continue to be space-delimited.
2023-10-04 11:24:37 <KipIngram   > Pros and cons both ways.
2023-10-04 11:25:13 <GeDaMo      > You could treat consecutive numbers as an array
2023-10-04 11:27:29 <KipIngram   > Yes, that's like APL.
2023-10-04 11:27:45 <KipIngram   > and then use ⋄ to terminate that if I wanted to start a second array.
2023-10-04 11:28:11 <KipIngram   > 1 2 3 ⋄ 4 5 6  == two vectors.
2023-10-04 11:28:30 <KipIngram   > Or (1 2 3) (4 5 6)
2023-10-04 11:28:40 <KipIngram   > Those are sort of the two possibilities.
2023-10-04 11:29:00 <KipIngram   > not necessarily ( and ), but some type of "bracket>"
2023-10-04 14:56:29 <veltas      > KipIngram: recursion in ANS is done with RECURSE
2023-10-04 14:56:52 <veltas      > Not having current def visible is quite useful for 'enhancing' previous definitions
2023-10-04 14:57:16 <veltas      > But it does mean you want to have some kind of 'prior' feature sometimes, especially for LOCATE or SEE
2023-10-04 14:57:54 <KipIngram   > Yeah, I use ME to recurse.
2023-10-04 14:59:05 <KipIngram   > And conditional variants for other looping.
2023-10-04 15:01:29 <KipIngram   > But I *could* recurse by name.
2023-10-04 15:13:29 <KipIngram   > I only loop to "start of word" as a matter of design - I factor to make that be what I need to do.
2023-10-04 15:58:06 <seepel      > KiIngram I experimented with something like your array delimiter. I treated the top of stack as a type tag. The first byte was the tag, and then the other three bytes were type specific data.  The rest of the data was then spread across the stack. I did the typical least two significant bits of the 32bit word breaking it up into
2023-10-04 15:58:06 <seepel      > 00 -> pointer
2023-10-04 15:59:30 <seepel      > 
ACTION Full disclosure, I haven't used the system extensively. It is still mostly a thought experiment.

2023-10-04 16:00:41 <seepel      > *KipIngram
2023-10-04 16:02:33 <KipIngram   > What I envision is a stack of pointers, and at the pointer destination I'd find my type information.  I've also considered a hybrid stack item, where the low bits are an address and the high bits encode a type.
2023-10-04 16:03:02 <KipIngram   > But I don't want an object to require multiple stack items - I want all the stack manipulation words to work in the usual way.
2023-10-04 16:03:32 <KipIngram   > Swap the top two items - you've swapped the top two objects, regardless of what they are.
2023-10-04 16:03:47 <KipIngram   > I should make clear that I don't plan to have my system work that way out of the box.
2023-10-04 16:03:55 <KipIngram   > at power up it will just be basic Forth.
2023-10-04 16:04:12 <KipIngram   > The type-aware stuff will require loading some source code and launching a more sophisticated interpreter.
2023-10-04 16:05:20 <KipIngram   > seepel: I've got a strong interest in scientific computing - number crunching.  So I want that higher tier system to work really well with vectors and matrices and stuff like that.
2023-10-04 16:05:36 <KipIngram   > That's why I've been interested in APL; looking for "stealables."
2023-10-04 16:06:08 <seepel      > That makes a lot of sense. APL is a language I haven't gotten to learning yet, but it seems quite intriguing.
2023-10-04 16:09:34 <KipIngram   > It really is, and it not like picking up "yet another mainstream language."  It's quite different, and learning those symbols adds a layer of memorization to it.  I found a tutorial that I thought was helpful:
2023-10-04 16:09:49 <KipIngram   > https://tutorial.dyalog.com/next.html
2023-10-04 16:10:03 <KipIngram   > You probably don't need the /next
2023-10-04 16:10:19 <KipIngram   > It's a little time consuming, but there's a lot to learn.
2023-10-04 16:10:41 <KipIngram   > I've done "most of it" once - I'll need to repeat some of it.
2023-10-04 16:11:29 <KipIngram   > APL is infix rather than postfix, and I'm struggling a little with how to move all of the features to a postfix setting.
2023-10-04 16:11:44 <KipIngram   > Without uglying up the way code looks too much.
2023-10-04 16:12:10 <seepel      > Yup, I started with lisp, then a little Agda, the Forth. I feel like something like APL is next on the list :)
2023-10-04 16:13:07 <KipIngram   > In APL a lot of the symbols can function either with right operands only (monadic) or with both left and right (dyadic).  APL works in a way that makes it possible to figure out which should be used in each case - that's one of the things that will be harder in RPN.
2023-10-04 16:13:30 <KipIngram   > there the stack will be sitting - but no way to tell whether the intent was monadic or dyadic.
2023-10-04 16:14:09 <KipIngram   > Someone posted a link here a few days ago to an RPN APL-like language called uiua.  They solved the issue by just limiting each symbol to one specific way of operating.
2023-10-04 16:14:15 <KipIngram   > But that means a bunch of new symbols.
2023-10-04 16:14:42 <KipIngram   > That you wouldn't be able to easily find keyboard support for.
2023-10-04 16:15:34 <Zarutian_iPad> KipIngram: can you explain monads?
2023-10-04 16:16:13 <KipIngram   > Not in a proper way.  I used the word there just to refer to a function that takes one operand.
2023-10-04 16:16:46 <Zarutian_iPad> aah, that is, one arity function then
2023-10-04 16:17:16 <Zarutian_iPad> arity saying on how many arguments a function or method takes
2023-10-04 16:17:26 <KipIngram   > Right.  I don't really know the fancy computer science usages of the term.
2023-10-04 16:19:53 <Zarutian_iPad> you can turn a multi arity function into single arity function via currying
2023-10-04 16:20:10 <KipIngram   > Ok.  That fits with my limited knowledge.
2023-10-04 16:20:12 <Zarutian_iPad> but many find that too spicy
2023-10-04 16:23:01 <KipIngram   > :-)
2023-10-04 16:23:27 <KipIngram   > Well, the idea of "pinning down" some of the parameters of a function to get a function with fewer parameters - that in itself isn't terribly challenging.
2023-10-04 16:23:45 <KipIngram   > But I bet they have some fancy notation for how to write it all down that would be unfamiliar to me.
2023-10-04 16:23:54 <KipIngram   > there's always "high lingo."
2023-10-04 16:28:16 <Zarutian_iPad> now currying is like just making a function or closure that captures the value of the argument being curried
2023-10-04 16:29:18 <Zarutian_iPad> partial evaluation on the other foot is way more interesting as that allows for use of optimazations that generally done in compilers
2023-10-04 16:30:54 <Zarutian_iPad> leads to stuff like explained in http://blog.sigfpe.com/2009/05/three-projections-of-doctor-futamura.html
2023-10-04 16:33:15 <KipIngram   > I want to think I've looked that over - maybe you mentioned it to me previously.
2023-10-04 16:34:28 <KipIngram   > Anyway, the two rubs I see in this are 1) the monadic/dyadic decision I talked about above and 2) deciding when to treat several consecutive items in the input as a vector vs. giving each one its own stack element.
2023-10-04 16:34:51 <KipIngram   > And I want to resolve those things without making everything see TOO much less tight and terse compared to APL.
2023-10-04 16:35:27 <KipIngram   > The "obvious" way to handle 2 is to put vector elements inside some sort of brackets, but that really rubs me the wrong way visually.
2023-10-04 16:52:22 <KipIngram   > The absence of parentheses is one of the nicest things about Forth.  One of the things I just discovered in APL is the commute operator ⍨ which flips the arguments the function right before it expects.  It can be used to weed parentheses out of an expression, and that was... pleasing.
2023-10-04 17:12:24 <FUZxxl      > KipIngram: just wait until you learn of trains, forks, and pointless style in general
2023-10-04 17:12:55 <FUZxxl      > forks are done with the iota operator ∘
2023-10-04 17:15:30 <FUZxxl      > F∘G is like {⍺F∘G⍵} for dyads, {F∘G⍵} for monads
2023-10-04 17:15:37 <FUZxxl      > i.e. it allows you to compose functions
2023-10-04 17:18:44 <KipIngram   > I thought iota was ⍳
2023-10-04 17:19:02 <KipIngram   > That little circle isn't a Greek letter, is it?
2023-10-04 17:19:07 <FUZxxl      > sorry, jot not iota
2023-10-04 17:19:12 <KipIngram   > Gotcha.
2023-10-04 17:22:40 <KipIngram   > I've been poking at APL off and on for a year or so, so I've seen at least a couple of references to trains and point free, though I'm nothing like "familiar' with them.