8 ms·

Rye: Homoiconic dynamic programming language with some new ideas

• gumby 3y ago
  > Rye is homoiconic, it has no keywords or special forms (everything is a function call, everything is a value) How does it implement and, or, or if?
  • chabons 3y ago
    Presumably as functions, the same way as excel? and(x, y) -> bool or(x, y) -> bool if(cond, funcTrue, funcFalse) -> void
    • adrianmsmith 3y ago
      Yeah I did notice in the examples fac: fn { x } { either x = 1 { 1 } { x * fac x - 1 } } ; function that calculates factorial So presumably "either" is the "if" expression.
      • anamexis 3y ago
        "if" is the "if" expression - https://ryelang.org/meet_rye/basics/if_either/ https://ryelang.org/meet_rye/basics/if_either/
        • acjohnson55 3y ago
          Yeah, but "either" is the if-else construct, so the person you replied to isn't really wrong.
    • deleted 3y ago
      [deleted]
    • sparkie 3y ago
      if(and(or(cond1, cond2), cond3), effect1(), effect2()) In most languages, if `cond1` evaluates to true, you would not evaluate `cond2`. If `cond1` and `cond2` evaluate to false, you would not evaluate `cond3`. If all conds evaluate to false, you would not evaluate `effect1()`, and if `cond3` and either `cond1` or `cond2` are true, you would not evaluate `effect2()` They're not functions because they don't evaluate their arguments before evaluating their body. Their operands are passed verbatim and evaluated explicitly by the body on demand. In Kernel, for example, we can define these as operatives, which don't evaluate their operands. Assuming we have some primitive operatives `$cond`, `$define!` and `$vau` (the constructor of operatives), and an applicative `eval`: ($define! and ($vau (lhs rhs) env ($cond ((eval lhs env) (eval rhs env) (#t #f))))) ($define! or ($vau (lhs rhs) env ($cond ((eval lhs env) #t) (#t (eval rhs env))))) ($define! if ($vau (condition consequent antecedent) env ($cond ((eval condition env) (eval consequent env)) (#t (eval antecedent env))))) These aren't the definitions Kernel uses in its standard environment. It uses recursive definitions of `$and?` and `$or?` which take arbitrary number of operands, and `$cond` is defined in terms of `$if`, which is primitive: ($define! $cond ($vau clauses env ($if (null? clauses) #inert ($let ((((test . body) . rest) clauses)) ($if (eval test env) (apply (wrap $sequence) body env) (apply (wrap $cond) rest env)))))) ($define! $and? ($vau x env ($cond ((null? x) #t) ((null? (cdr x)) (eval (car x) env)) ((eval (car x) env) (apply (wrap $and?) (cdr x) env)) (#t #f)))) ($define! $or? ($vau x env ($cond ((null? x) #f) ((null? (cdr x)) (eval (car x) env)) ((eval (car x) env) #t) (#t (apply (wrap $or?) (cdr x) env)))))
      • anamexis 3y ago
        I don't think that's what Rye is doing. It's doing if(cond, effect1, effect2) where effect1 and effect2 are functions, and only evaluating the matching effect function. But everything is functions.
        • middayc 3y ago
          technically effect1 and effect2 are so called "blocks of code" in rebol/rye/red/... Everything being a function is trying to say that every "active word" (a word that does something ... print, first, if, fn, context, extends, ...) is just a function.
  • samatman 3y ago
    This is possible with fexprs or equivalent constructs https://en.wikipedia.org/wiki/Fexpr https://en.wikipedia.org/wiki/Fexpr It looks like that's how Rye does it as well, blocks can be conditionally evaluated: https://ryelang.org/meet_rye/basics/if_either/ https://ryelang.org/meet_rye/basics/if_either/ "In REBOL, contrary to Lisps, blocks or lists don’t evaluate by default. For better or for worse, this little difference is what makes REBOL - REBOL." https://ryelang.org/meet_rye/basics/doing_blocks/ https://ryelang.org/meet_rye/basics/doing_blocks/ It's difficult for a language with this semantics to be made efficient, but efficiency isn't everything.
    • fuzztester 3y ago
      >programming language based on ideas from Rebol, flavored by Factor, Linux shell and Go That makes it potential interesting to me.
      • fuzztester 3y ago
        potentially, autocorrect incorrect :)
    • _nalply 3y ago
      Why is it difficult?
      • samatman 3y ago
        Since code-is-data, you can put that exact if statement into several functions. Since code-is-data, you can swap the if and else clauses around. This applies to all the functions where you've inserted the if statement. This kind of thing makes it difficult to compile a function to a fast set of machine instructions with the same effect. Not impossible, but difficult.
      • sparkie 3y ago
        It's difficult to optimize because evaluation of expressions depends on the dynamic environment, which you don't have ahead-of-time. You can't even assume `+` means "add the arguments", because `+` may have been bound to something completely different prior to evaluating the expression containing `+`.
  • justinpombrio 3y ago
    This took me a minute to get, even after looking at the page about if: https://ryelang.org/meet_rye/basics/if_either/ https://ryelang.org/meet_rye/basics/if_either/ The tricky thing about if, and, and or --- the reason you can't implement them as functions in most languages --- is that they need to not evaluate all their arguments immediately. Otherwise: // Would print! if(false, print("oops!")) // Would throw an error if the key is not present and(my_hashmap.has_key("key"), my_hashmap["key"]) The way that ryelang gets around this is that you pass the arguments in a "code block" surrounded by "{}", which delays its evaluation. So you write: // Does not print, because *if* never runs its code block arg if 0 { print("oops!") } // There's no example of *and* anywhere but my guess is you'd write this: and { my_hashmap.has_key("key") } { my_hashmap["key"] }
    • nerdponx 3y ago
      The R language has this feature as well. It's a whole lot of fun to work with.
      • dmux 3y ago
        Likewise in Tcl where blocks can either be sent quoted (using {}) or unquoted (using “”). In the latter, variables and procs will have a round of substitution performed before being passed to the proc.
        • middayc 3y ago
          Rebol (where Rye took this from) is many times associated with Tcl. I've heard good things about it, but haven't really tried it yet.
          • spindle 3y ago
            TCL is kinda similar to Rebol in some ways but in other ways it's the opposite of Rebol, because in TCL everything is a string (although it can ALSO have another type, thanks to clever shenanigans). (You probably knew this!)
  • middayc 3y ago
    Yes, as samatman said, main reason is that blocks of (code or data there is no difference) don't evaluate so they are passed as function arguments and the function can potentially evaluate them. So if is a function that accepts two arguments, a boolean and a block of code. loop is a function that also accepts two, integer for number of loops and again a block of code. Even fn that creates functions is a function that accepts two blocks, first is a list of arguments and second is a block of code. There is no big difference between function fn and function print, they are both builtin functions defined in same manner and there are multiple fns for special cases and you can create your own on "library" level.
  • choeger 3y ago
    In a eagerly evaluating functional language you could always wrap the arguments in a thunk: So if your built-in functions were implemented in Python, you'd use: def if_(cond, t, e): if cond: return t() else: return e()
    • deleted 3y ago
      [deleted]
• warvariuc 3y ago
  The blog entry titled "Less variables, more flows example vs Python" is strange. ( https://ryelang.blogspot.com/2021/11/less-variables-more-flows-example-vs.html?lr=1 https://ryelang.blogspot.com/2021/11/less-variables-more-flo... ) The Python version uses intermediate variables so the author of the code is to blame for verbosity, not the language.
  • middayc 3y ago
    This was written in 2021, maybe it's really not that great of a blogpost. I wrote a lot of blogposts from many angles back then, mostly to myself as there weren't many readers, trying to see the language from the outside, to self-motivate, etc ... I think I wrote a script I needed in Rye and I found it interesting, then I went to Fiver and paid someone to write a script in Python that does the same. 2021 were different times, and I hope I've grown a little too... and now I would ask ChatGPT or Gemini :)
  • woolion 3y ago
    It is a legitimate complaint of the language as there are language-related reasons that motivates it --the conciseness of the language has an impact on readability, but also how convenient it is to debug on separate lines. The code examples are a tad too verbose but actually better quality than most real-world Python codebases, I would say. Python is not very verbose but it's not very concise either (especially compared to Lisp families)
  • amluto 3y ago
    ISTM the big difference is that the Python code is doing CGI essentially from scratch, but the rye code appears to be using a CGI library.
    • middayc 3y ago
      The Pyhton side does have import cgi. It also uses req library for request parsing and making a post request. Only for cookies it uses os.environ which is maybe a little unusual, but I didn't specify in fiverr request what libraries to use or not use.
  • 3y ago
• carterschonwald 3y ago
  The detail about input validation is a really nice one that hopefully the next generation of programming languages all do standard.
  • deleted 3y ago
    [deleted]
  • RodgerTheGreat 3y ago
    It sounds intriguing, but it doesn't look like there are any examples in the readme, and the documentation for the Validation dialect on ryelang.org is completely blank. How does this feature work?
    • middayc 3y ago
      Hi, you can see a smaller example on ryelang.org front page if you ctrl+f "validation". Here are unit tests / reference for the validation dialect, but they aren't the best source of information: https://ryelang.org/validation.html https://ryelang.org/validation.html Here is an old blogpost with another example: https://ryelang.blogspot.com/2021/01/added-intro-pages-for-hof-s-validation.html https://ryelang.blogspot.com/2021/01/added-intro-pages-for-h... It's a dialect with static/builtin rules that can be combined and two rules that accpet blocks of Rye code so they can do anything (check and calc, first checks value for certain condition, second changes / calculates new value from the old) I've written about validation dialect in previous attempts, but current one "Meet Rye" is still in the process of being written and I will get to this.
      • carterschonwald 3y ago
        It’s definitely an idea which I’ve seen people wish Haskell had. But requires some machinery that’s not quite in that language. I guess it’s easy to express in a dependently typed language to an extent.
        • middayc 3y ago
          This validation dialect (and SQL dialect are main things) I used in all my web development for years using Rebol. So in Rye I made it part of the base builtins. It's nothing particularly special or complicated and could be improved to cover more cases. I then had custom functions in Rebol that instead of argument list accepted this validation block and what it returned gor serialized into JSON and returned from the webserver. In case of valiadation error it also got automatically returned and sent back. So you defined such fucntions in a context and got an web accesible API and also you could call them on serverside to render something there (or fill in JSON directly into page that is served). Function in Rebol (and Rye) also have a docstring and it's accesible within the language so these functions could also self-document. Show their description and validation rules if you called them with &_x=1 (as in explore mode). Of course I tried to redo all this in Rye and make it even better for this. Ok ... I got a little carried away ... :)
• artemonster 3y ago
  familiar with rebol, but evaluation rules with op and pipe words gave me headache. would like to know more about context oriented programming, tutorial had nothing in the section, unfortunately
  • middayc 3y ago
    Yes, op and pipe words are the biggest or the most visual addition to Rebol's base idea. Without them if you replace { } with [ ] it's basically just Rebol ... well, with some different details around contexts (rebol's bindology), no refinements, mandatory spacing around tokens, different error handling logic and some other details. I am still learning to explain or even name things, but various examples of using contexts in different ways are currently what excites me the most. I will write "Meet Rye" further and contexts are one of next subjects to be written about.
    • bradrn 3y ago
      > with some different details around contexts (rebol's bindology) Could you perhaps summarise how contexts work in Rye? On the Ren-C forum we’ve recently been discussing binding a lot, and I’d be interested to learn how Rye does it.
      • middayc 3y ago
        The context in Rye nothing special, but I'm excited about how all it can be used ( and the context details could change a little too in future). Context is just a namespace of "word: value"-s and an optional link to a parent context. When a word is being searched it looks in the current context and if it's not found it goes up to parent, etc. One interesting things about contexts are what I called "isolates", a context that is isolated from anything else, but can hold a set of functions specialized for a certain task. Or you can construct and string together custom contexts to create a desired environment for certain code. When you have a context, you can evaluate code in context, you can call functions in context from outside, you can create functions that are evaluated is a specified context or with a specified parent context, etc ... You can also move through contexts and list them in Rye console like you would through directories. I don't know if I answered your question well ... I'm maybe better at showing than explaining. I'm preparing an asciinema demo called "contextplay".
• leke 3y ago
  I played around with Rebol many years ago and enjoyed it. This too looks like fun.
• djaouen 3y ago
  Congrats, this language looks pretty cool! What advantages does it have over, say, something like Elixir?
  • middayc 3y ago
    It's difficult to compare it directly to Elixir since Elixir is a production ready language built on top or Erlang VM. Elixir certainly has more solid runtime, as Rye is interpreted. But Rye probably has much more malleable runtime that you could maybe better structure and specialize around your problem.
• 1propionyl 3y ago
  The email type seems just a smidge too specialized for me. It could more broadly be an "authority" type (borrowing URI/URN terminology) a la: authority = [userinfo "@"] host [":" port] The simple extension of allowing a port makes it a more broadly useful type, since authorities like above appear all over the place. Email is just one protocol after all. There is also a url type, but it is unclear how general it is (just http/s?). There is a cpath type which corresponds to the path in a URI as well. URI = scheme ":" ["//" authority] path ["?" query] ["#" fragment] In Rye typing, authority _could_ be the authority described above, and cpath already covers path. The rest are strings as they don't have generically defined syntax. Perhaps this is a bit of a quibble but it seems to me like if URIs and their structured components (cpath is already there, and email is so close!) were core types rather than just email and url, it opens up a lot of use cases.
  • middayc 3y ago
    Hm. Interesting proposition. Rye inherited email and URL data types from Rebol. I haven't done that much on them specifically, because they aren't that crucial to the design of the language dynamics, so their implementation certainly should be improved (ant thought about). The idea of making them more general certainly makes sense. Rye is "end-user" focused so it would maybe still be called email. URI-s right now can have different schemes. Scheme defines the kind of url and Rye has generic functions that dispatch on the kind of first argument. So there is: open file://readme.txt and open sqlite://db.s3db and open postgres://user@localhost/database "pwd" ... %path/notes.txt is also Rebolism and it's a shorthand for file://path/notes.txt Thank you. I will think about this cpath is currently a little specific, at least in behaviour as it's a context path to a word. Thank you for making this comment. I will think more about it and certanly reread it when I work on there datatypes next time.
• c4pt0r 3y ago
  Seems like a good Swiss Army Knife-like addition to the shell script (reminds me of awk as well). It would be interesting to keep it that simple (not another Perl)
  • middayc 3y ago
    Awk was one of early use-cases I wanted to make it useful for. It still has "Ryk" mode, but I haven't tested it in years so I'm not sure if it works right now. Rebol was known for its small set of moving parts and behaviors but with a lot of depth and flexibility with them. I've added some moving parts with left to right code flow, but I still hope it's a limited set that fits well together. I am adding new behaviors very conservatively now, and I will remove some. Thanks for heads up about Perl! ;)
• kunley 3y ago
  About getters.. are they foo? or ?foo ? The examples have it mixed, "Meet Rye" doc has it as ?foo
  • middayc 3y ago
    If you don't come from Rebol it would probably be weird to you that there are many specific word-types in Rye. name: Janko ; name: is a set-word - it binds value to a word ?print ; ?print is a get-word - it get's value word is bound to in this case a print builtin function :age ; left leaning set-word (this is get-word in Rebol) what? ; just a regular word ... name get's the value anyway, so we don't need to use ?name but if word is bound to a function just invoking a word will evaluate a function and if we want to return a funtion we use get-word. which has ? in front. ? at the end is just a regular word and a (currently accepted) naming convention where noun? means get-noun. so length? in instead of get-length etc. Rebol used ? at the end convention for more things, a lot for boolean results, testing of types, like string? and positive? but also for lenght? For booleans current Rye's naming convention is that we use is-adjective. Rebol used positive? to test if value is positive. We would in this way use is-positive. The conventions might change if we see that there are ways that make more sense and are also consistent.
    • kunley 3y ago
      Thanks for the explanations. Indeed I don't come from Rebol and the conventions seem like a terra incognita, although I can sense a significant value in them. From a past romance with Forth I see in general how concatenative languages seem to be underappreciated a bit