Meaning of "Error not pointer so bug. #temp"?

[jaredkrinke]

(First attempt at using Rye) I'm trying to load a file with a bunch of quoted, comma-separated strings (all on one line), but when I load %file.txt, I see the following error:

Error not pointer so bug. #temp

What does this error mean? Is it pointing out a bug in my code or in Rye itself?

For the record, I don't know if load should be able to handle my file--but the output shows a bunch of quoted strings separated by commas, within a pair of braces, so it seems like it's on the right track, other than the error message. The file is from this Project Euler problem.

[refaktor]

Hi. Thanks for writing. "Error not pointer so bug" means a bug in Rye code. It's more of a temporary measure.

Load works on strings and files and it tries to "load" (parse) Rye values from text. The problem with the file is that Rye (contrary to Rebol) expects spaces between all the tokens in it's code.

You could to this for example:

read %098_words.txt |replace "," " " |load

this would give you a block of words ... then map could come handy.

Great that you are trying to do Project Euler. I haven't yet found time for it.

[refaktor]

@jaredkrinke I've uploaded the Fix. Are you building Rye from Go source or are you using generated binaries? If so, I could make a new release, but I will also add escape sequence for " before release.

// update:
If you are doing something like Euler with Rye, you will need a lot of basic functions, so please check the reference:
https://ryelang.org/info/base.html

It's generated from tests (which are taken from comments above the definition above each builtin). This page is the very first version, the tests, the rendering and all will improve but it can be more helpfull than nothing I guess.

[refaktor]

Hm .. I forgot about split\quoted :)

I looked a little at the Euler problem and it seems more complex than on first sight.

One thing that might give you problems for some algorithms, haven't been thinking what is needed here:

Rye basically doesn't (at least for now) have much support for mutable data structures. If does have append! for blocks and lists, but this whole subject is in design still. It doesn't have anything typical like a['b'] = 'c' for dicts (or contexts) really. You can create a block and turn it into a dict or context. For some things where you append things together, there is a produce HOF-like function.

[jaredkrinke]

Disclaimer: Project Euler isn't representative of what Rye users are probably looking for, and I... don't really know what I'm doing and haven't experienced "Rebol zen" yet. Having said that...

Thanks! I came up with a solution using a functional approach. My biggest struggles (as someone who briefly tried Rebol a few months ago) were:

• Took me a long time to find a way to create a block with non-static data -- I eventually saw some sample code using [ ... ], which appears to evaluate its body and then toss the results into a block (like list in Lisp?) -- is [ ... ] documented somewhere?
• I haven't taken the time to understand passing around functions vs. passing around blocks that are actually code -- I probably need to meditate on contexts first :)
• It would have been nice to have customizable versions of sort, intersection, etc. (to sort by some field or by the result of calling a function on each item) -- I think I've seen these in most functional languages
• Also would have been convenient to have a "group by" function that gathered items into a list instead of computing SQL-like aggregates -- not sure of the right terminology for this

For the record: I like the simple syntax of Rye -- it results in very compact code that is still readable. I was also impressed with how fast Rye is! The Excel integration is intriguing--hopefully I can come back and test that out at some point. Overall, it's probably the most promising Rebol-like I've found (compared to classic Rebol, Red, Boron)!

[refaktor]

Wow! This is the most complex compact Rye code I've seen, and I've probably written >90% of Rye code that exists so far :)

It's really impressive that you were able to adapt to so many Rye specifics (op/pipe words, * at the end of the word (second arg from the left), expression guards, HOF-like functions, eval blocks [ ] (don't have a name yet)), and use them as they were meant to be used. Also the shape of code is what it was supposed to be like, not that I'm the absolute measure.

Undocumented but thought about idea was that Rye code is formed around "sentences" (not lines / statements) and each sentence generally has one point, defines / calculates or does something specific. For example function find-anagrams is a textbook example of it. Really nice.

find-anagrams: fn { l } {
  info: l |map { ::w [ w sort-word w ] } ,
  anagrams: info |map { .second } |sort |partition { , } |filter { .length? > 1 } |map { .first } ,
  info
    |filter { ::x contains? anagrams second x } |map { .first }
    |group { .sort-word }
    |map { .second .pairs\permutations }
    |concat\lists
} 

It's also really nice that you were able to use the functional approach, the various HOF-like functions so much.

About your struggles:

• Rebol / Rye blocks are unevaluated by default, and Rebol uses function reduce to evaluate them. a: 33 probe reduce [ a ]. Reduce now has strong association with HOF reduce, so I didn't use that word. I was trying various names, looking for something short and not a weird abbreviation, because you have to use it a lot. I tried (minimize, valuate, eval, evalu) ... currently it's "vals" ... eval would be a nice one, but it's already too associated with code evaluation in JS, which is not the same thing. Last year I decided to add an additional syntax rule and use [ ] which was to that point the same as { } in general dialect as a "vals" block, and it does work well in many cases so it will stay. I haven't documented it yet. By the same logic ( ) bacame the "do" block. Doing the same as do { 123 + 234 } and also behaving as one would expect from parenthesis.
• all HOF-s (filter, map, ...) will support accepting a block of code or a function for the "do" argument. Some already do, but it's not implemented for all of them. Using anonymous function is cleaner conceptually and you don't need to use ::x (mod-words), but using just blocks looks simpler in many cases and is faster because you evaluate code in the same context. Otherwise some functions accept blocks of code (loop, if, fn, ...) some both, some just functions ... depending on what seems to make sense (but I will try to unify it / make it internally consistent as much as possible)
• yes, these just haven't been added yet ... I mostly add builtins as I need them ... I will add them to a TODO list.
• There is a limited function group that would have to be improved still, currently it just accepts string keys and returns a dict, not sure if it would help:

{ 1 2 3 4 5 } |group { .odd |to-string }
[Dict (): 1: [List ():  1  3  5 ] 0: [List ():  2  4 ] ]

Really thank you for using Rye for your experiment! I must admit I don't fully get the code / algo yet ... I will take time and then see if you missed something or if I could improve on it, but so far it really looks like a proper Rye-thonic code :) ... and thank you for the feedback you provided!
Rye :).

One question: Did Rye console / REPL come in handy in trying to solve the problem?

I will be probably linking to your project because I'm a little proud that somebody used Rye, and I was already checking other problems / languages on your list.

[jaredkrinke]

Thanks for the kind words! I had seen Rye on Lobsters and thought the idea of a modern Rebol built on Go was a great idea--it had been on my list to try for a long while! For side projects and experiments, I like simple, flexible languages that are easy to deploy. Theoretically, I prefer the consistency of a Lisp, but Rebol/Rye can be easier to read and don't scare parenthesis-wary people off as quickly :)

One question: Did Rye console / REPL come in handy in trying to solve the problem?

I used the interactive prompt for testing little snippets--mostly to make sure built-ins worked the way I thought. If I was tackling a larger project, I'd probably explore more (esp. if it had any sort of built-in debugging for errors--no idea if that's the case). I just had Vim open and had an auto-rerunning invocation of ./rye file.rye (via ENTR).

With respect to other comments: I actually had no idea that ( ... ) was basically just syntactic sugar for a do--I was wondering how it worked in the context of Rebol-like simple syntax! Also, group probably would have worked for me in multiple cases--I just didn't understand what it was doing and then wrote something similar, but worse :)

As for my solution (spoiler alert!):

Details

I think the trickiest parts are a) working around lack of custom sort/intersection and b) how anagrams are "normalized" into a representation that is unrelated to whether the words use digits or letters (or which specific digits/letters). The main idea is to describe the transformation from one word to another by only using the position of each character in the first word, e.g. to convert "care" -> "race" you take characters with 1-based indices from "care" in this order: 3, 2, 1, 4, so I describe this transformation as "3214". This same approach works for digits, so we just have to find numbers with the same transformation. Some tricks are needed around words with duplicated characters.

[refaktor]

Very cool! ... I will add sort / intersection and try to tune your example, to improve functions and think of other details that would make problem like you solved more elegant (hopefully I find time this weekend).

Your solution is interesting, I wouldn't have figured it out that way :) ...

I see your github page is second on HN frontpage 👍

[refaktor]

Just small detail in case you were not aware. We have a fn1 function that creates a function accepting 1 argument and injecting it (but sometimes you do want to name the argument), and also regular function injects first argument ... not saying it's better, just FYI:

split\characters: fn1 { .split "" }
contains?: fn { l i } { ( .filter { = i } ) .length? > 0 }
concat\lists: fn { list } { .reduce 'acc { .concat* acc } }
; .....
get-transformation: fn { pair } {
  .first :a , .second :b ,
  al: ( a |split\characters ) ,
  a1: al |map { .position?* a } |join ,
  a2: al |map { .position?* b } |join ,
  join [ a1 "-" a2 ]
}

[refaktor]

@jaredkrinke I added sort\by and intersect\by. Reference is here:

https://ryelang.org/info/base.html#heading-sort\by
https://ryelang.org/info/base.html#heading-intersection\by

Quote escaping was also added. Thanks!