51–60 of 86 posts
The blog entry titled "Less variables, more flows example vs Python" is strange. ( 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.
Earlier quoted context omitted.
This took me a minute to get, even after looking at the page about if : 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.…
As done in Smalltalk.
The code block approach is widely applied in two massively used industrial languages though: Ruby and Kotlin. In Kotlin specifically it's one of the very central features.
Earlier quoted context omitted.
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.
"if" is the "if" expression - https://ryelang.org/meet_rye/basics/if_either/
Earlier quoted context omitted.
This took me a minute to get, even after looking at the page about if : 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.…
> The way that ryelang gets around this is that you pass the arguments in a "code block" surrounded by "{}" Like Lisp’s QUOTE which has to be a special form.
[1] https://maxima.sourceforge.io/
[2] https://feb.kuleuven.be/public/u0003131/WBT23/wxMaxima/wxM_i...
[3] https://feb.kuleuven.be/public/u0003131/WBT23/wxMaxima/wxM_i...
[4] although (in my limited experience) maxima sometimes refuses to evaluate anyway even if you do the double quote thing
Earlier quoted context omitted.
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.
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.
The blog entry titled "Less variables, more flows example vs Python" is strange. ( 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.
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.
> 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 ?
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()Earlier quoted context omitted.
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.
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!)
> 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 ?
Presumably as functions, the same way as excel? and(x, y) -> bool or(x, y) -> bool if(cond, funcTrue, funcFalse) -> void
if(and(or(cond1, cond2), cond3), effect1(), 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)))))
($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)))))> 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 ?
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()