In fact, I would say that the above code examples are definitely not represented with maps – since maps are unordered and the code above depends on being sequenced.

Small point of contention; the maps above are listed in order, but only for clarity’s sake. There is no reason to think that they would need to be.

-m

Thank you for the thoughtful posts. You’ve definitely elaborated on my sugared examples. I tried to make a more readable version, but you’ve captured a more homoiconic illustration. I would be interesting to take these thoughts further, I only hope that time allows me to do so.

-m

{
  weird-fac:fac[ x:0 ]:0      ;; factorial where fac(0) = 0
  
  fac:{                       ;; simple factorial
    { x:0 }:1
    
    args:if[
      cond:<[ left:args[x] right:0 ]
      then:fac[ x:0 ]
      else:*[
        0:args[x]
        1:fac[
          x:-[ 0:args[x] 1:1 ]
        ] 
      ]
    ]
  }
}

do[
  0:print[ str:"Enter a number: " ]
  1:let[ num:readLine[]
    body:println[
      str:format[ str:"Factorial of %d is %d" 0:num 1:fac[ x:num ] ]
    ]
  ]
]

The weird-fac “function” demonstrates remapping existing values. So, weird-fac is equal to the fac map with the x:0 key remapped to the 0 value. Map keys can themselves be maps, values or symbols. Function calls (if you can give it that term) are done by dereferencing the “function” map based on its key. In the case of a function, that key is most often a map itself, but it can of course be a value as well.

It’s just an idea, but I think you get the picture.

{ call:letrec name:fac    ;; cheaters way of avoiding fixpoint
  value:{ call:def args:args
    body:{ call:if cond:{ call:<= x:args[x] y:1 }
      then:1
      else:{ call:* 
        0:args[x] 
        1:{ call:fac x:{ call:- 0:args[x] 1:1 } } } } } }

Obviously, all of this could have been more elegantly accomplished using Lisp. That’s because I’m not really exploiting the map data structure in any way. Also, I suspect that maps aren’t as ideally suited to lambda calculus as are lists. It deserves some thought…

Which goes back to my original point, I’m not sure if it even makes sense to represent code as maps, and I certainly can’t imagine what it would look like – and you have no content in this blog post about it either.

In fact, I would say that the above code examples are definitely not represented with maps – since maps are unordered and the code above depends on being sequenced.