4 ms·

Seems lispy

taeric 1y ago
Without the discussion of applicative-order versus normal-order.
middayc 1y ago
BTW: In Lisps, if is still a special form / macro, because in Lisp lists are evaluated by default, in Rebols if can be a function because blocks (lists) aren't evaluated by default.
- kazinator 1y ago
  You can rarely successfully generalize about languages in the Lisp family. :) TXR Lisp: (relevant to this article) there is an iff function that takes functional arguments. Square the odd values in 0 to 9: 1> (mapcar [iff oddp square use] 0..10) (0 1 2 9 4 25 6 49 8 81) The use function is a synonym of identity: i.e. just use the incoming value as-is Square the even ones instead by inverting oddp with notf: 2> (mapcar [iff [notf oddp] square use] 0..10) (0 1 4 3 16 5 36 7 64 9) Get rid of use with iffi: a two-argument iff with an implicit identity else: 3> (mapcar [iffi oddp square] 0..10) (0 1 2 9 4 25 6 49 8 81) Now about the point about Lisps and if: the regular if operator with value and expression arguments has a companion if function: 4> (special-operator-p 'if) t 5> (fboundp 'if) t Unlike in some other dialects like Common Lisp, a symbol can have a binding in the macro or operator space, and in the function space at the same time. But this if is not useful control. It's useful for things like being able to map over a function-like facsimile of the if operator. E.g. take an element of the (a b c d) or (x y z w) list depending on whether the leftmost list has a nil or t: 6> [mapcar if '(nil t nil t) '(a b c d) '(x y z w)] (x b z d) In the reverse direction, being able to write a macro for a function function exists, allows for ordinary macros to be "compiler macros" in the Common Lisp sense: provide optimizations for certain invocations of a function. This dialect is not even "weird"; overall it is Common-Lisp-like. Right down to the multiple namespaces, which is why the [...] syntax exists for referring to functions and variables in a combined virtual namespace.
  - veqq 1y ago
    What's the benefit of being implemented as lisp-2 but acting like lisp-1 with [ ]? Why not just be a lisp-1? > TXR is an original notation for matching entire text documents or streams, inspired by the unification that underlies logic programming systems This has me hooked.
    - kazinator 1y ago
      while there are certain simplicities and economies in a Lisp-1, it's a bad idea on the whole, and has irksome disadvantages. Lisp-2 also has irksome disadvantages, like the verbosity in code working with functional arguments. I want to give myself and my users the advantages of Lisp-1 and Lisp-2, as well as ways to avoid their respective disadvantages, so there is no way to get around having some kind of combination that lets us work in different styles.
bloaf 1y ago
I checked the Rye homepage, and it has "dialects" which allow more familiar math infix notation. In that sense it is very tcl-y, tcl technically being a lisp. Looking at their rather confusing looping mechanisms, they probably could benefit from being a little more tcl-y, since tcl has some of the best looping semantics I've worked with.
- middayc 1y ago
  Any concrete feedback on looping mechanisms being confusing is appreciated.
  - bloaf 1y ago
    Certainly: I can tell the rye devs like the idea of everything being a function. But in their very first "language basics" section, they introduce assignment not as a function call, but as some kind of magic that happens when you have colons in a name. So when we get to the "looping" section, it is the first time we have seen a colon-having-name outside the context of assignment: > loop 3 { ::i , prns i } And it is explained that the above line of code is "injecting" values for the code block to "pick up". But right away this begs a number of questions: * Why the double-colon? I would assume each loop-body-evaluation happens in its own scope, and that we're not creating global variables, so a single colon (:i) should be sufficient, right? * What are we doing, conceptually? Is the ::i meant to be "a function which when given a value modifies its enclosing scope to include the symbol i" or "an unassigned symbol which the loop function will use to do something akin to term-rewriting with?" * Do we really need a symbol at all, or could we just have a the point-free loop "loop 3 {prns}"? * If we can't have the point free thing, is it because somehow the injected value would end up "to the left" of prns, if so, why would we want that? * If we're doing something more like term rewriting, why isn't the symbol given as a separate argument from the body?
    - middayc 1y ago
      Rye is foremost a REBOL and REBOL has this notion of many types of words at it's core: `word` - regular word, can evaluate to value it's bound to or call a funtion if bound to a function `word: "value"` - set-word, assignment that you noticed `probe :word` - get-word, always returns bound value, doesn't call a function if it's bound to a function, in Rye this is `?word`, because `:word` is left-set-word. `'word` - literal word, evaluates to a word itself etc ... Rye adds even more word types. Rye also has left to right flow so it adds left-set-word. In Rye all assigned words with set-words are constants and they are used by default. So we also need a "mod-word", that is the double colon that you noticed, and left-mod-word. Because of left-to-right flow Rye also has .op-words and |pipe-words. The logic around words, op-words and pipe-words ... I tried to explain here: https://ryelang.org/meet_rye/specifics/opwords/ https://ryelang.org/meet_rye/specifics/opwords/ Another pattern you noticed (good observation btw:) is the idea of injected blocks that isn't used just for loops, but also for conditionals, function bodies, HOF-like functions etc ... https://ryelang.org/meet_rye/specifics/injected_blocks/ https://ryelang.org/meet_rye/specifics/injected_blocks/ All in all it is supposed to be a compact set of ideas that fit together. Some are somewhat unusual.

Seems lispy

Without the discussion of applicative-order versus normal-order.

BTW: In Lisps, if is still a special form / macro, because in Lisp lists are evaluated by default, in Rebols if can be a function because blocks (lists) aren't evaluated by default.

kazinator 1y ago
You can rarely successfully generalize about languages in the Lisp family. :) TXR Lisp: (relevant to this article) there is an iff function that takes functional arguments. Square the odd values in 0 to 9: 1> (mapcar [iff oddp square use] 0..10) (0 1 2 9 4 25 6 49 8 81) The use function is a synonym of identity: i.e. just use the incoming value as-is Square the even ones instead by inverting oddp with notf: 2> (mapcar [iff [notf oddp] square use] 0..10) (0 1 4 3 16 5 36 7 64 9) Get rid of use with iffi: a two-argument iff with an implicit identity else: 3> (mapcar [iffi oddp square] 0..10) (0 1 2 9 4 25 6 49 8 81) Now about the point about Lisps and if: the regular if operator with value and expression arguments has a companion if function: 4> (special-operator-p 'if) t 5> (fboundp 'if) t Unlike in some other dialects like Common Lisp, a symbol can have a binding in the macro or operator space, and in the function space at the same time. But this if is not useful control. It's useful for things like being able to map over a function-like facsimile of the if operator. E.g. take an element of the (a b c d) or (x y z w) list depending on whether the leftmost list has a nil or t: 6> [mapcar if '(nil t nil t) '(a b c d) '(x y z w)] (x b z d) In the reverse direction, being able to write a macro for a function function exists, allows for ordinary macros to be "compiler macros" in the Common Lisp sense: provide optimizations for certain invocations of a function. This dialect is not even "weird"; overall it is Common-Lisp-like. Right down to the multiple namespaces, which is why the [...] syntax exists for referring to functions and variables in a combined virtual namespace.
- veqq 1y ago
  What's the benefit of being implemented as lisp-2 but acting like lisp-1 with [ ]? Why not just be a lisp-1? > TXR is an original notation for matching entire text documents or streams, inspired by the unification that underlies logic programming systems This has me hooked.
  - kazinator 1y ago
    while there are certain simplicities and economies in a Lisp-1, it's a bad idea on the whole, and has irksome disadvantages. Lisp-2 also has irksome disadvantages, like the verbosity in code working with functional arguments. I want to give myself and my users the advantages of Lisp-1 and Lisp-2, as well as ways to avoid their respective disadvantages, so there is no way to get around having some kind of combination that lets us work in different styles.

bloaf 1y ago

I checked the Rye homepage, and it has "dialects" which allow more familiar math infix notation. In that sense it is very tcl-y, tcl technically being a lisp. Looking at their rather confusing looping mechanisms, they probably could benefit from being a little more tcl-y, since tcl has some of the best looping semantics I've worked with.

middayc 1y ago
Any concrete feedback on looping mechanisms being confusing is appreciated.
- bloaf 1y ago
  Certainly: I can tell the rye devs like the idea of everything being a function. But in their very first "language basics" section, they introduce assignment not as a function call, but as some kind of magic that happens when you have colons in a name. So when we get to the "looping" section, it is the first time we have seen a colon-having-name outside the context of assignment: > loop 3 { ::i , prns i } And it is explained that the above line of code is "injecting" values for the code block to "pick up". But right away this begs a number of questions: * Why the double-colon? I would assume each loop-body-evaluation happens in its own scope, and that we're not creating global variables, so a single colon (:i) should be sufficient, right? * What are we doing, conceptually? Is the ::i meant to be "a function which when given a value modifies its enclosing scope to include the symbol i" or "an unassigned symbol which the loop function will use to do something akin to term-rewriting with?" * Do we really need a symbol at all, or could we just have a the point-free loop "loop 3 {prns}"? * If we can't have the point free thing, is it because somehow the injected value would end up "to the left" of prns, if so, why would we want that? * If we're doing something more like term rewriting, why isn't the symbol given as a separate argument from the body?
  - middayc 1y ago
    Rye is foremost a REBOL and REBOL has this notion of many types of words at it's core: `word` - regular word, can evaluate to value it's bound to or call a funtion if bound to a function `word: "value"` - set-word, assignment that you noticed `probe :word` - get-word, always returns bound value, doesn't call a function if it's bound to a function, in Rye this is `?word`, because `:word` is left-set-word. `'word` - literal word, evaluates to a word itself etc ... Rye adds even more word types. Rye also has left to right flow so it adds left-set-word. In Rye all assigned words with set-words are constants and they are used by default. So we also need a "mod-word", that is the double colon that you noticed, and left-mod-word. Because of left-to-right flow Rye also has .op-words and |pipe-words. The logic around words, op-words and pipe-words ... I tried to explain here: https://ryelang.org/meet_rye/specifics/opwords/ https://ryelang.org/meet_rye/specifics/opwords/ Another pattern you noticed (good observation btw:) is the idea of injected blocks that isn't used just for loops, but also for conditionals, function bodies, HOF-like functions etc ... https://ryelang.org/meet_rye/specifics/injected_blocks/ https://ryelang.org/meet_rye/specifics/injected_blocks/ All in all it is supposed to be a compact set of ideas that fit together. Some are somewhat unusual.