Comments & Submissions | Comments | Submissions

raymyers

Sort by: Relevance | Points | Date Posted
"arc-mode.el for emacs"
13 points by raymyers over 2 years ago | link | top
cached about 17 hours ago
"extras/arc.el" on the git. We have Eric and Nathan to thank.

http://git.nex-3.com/arc-wiki.git?a=blob_plain;f=extras/arc....

Profiler on Anarki
12 points by raymyers over 2 years ago | link
cached 9 days ago
"The Factor Language"
9 points by raymyers over 2 years ago | link | top
cached 2 days ago
I have this friend, really sharp guy.

When we were sophmores he was learning Lisp, which was greek to me. ("What the heck is a lambda?!") Two years later, Lisp was my favorite language.

By then, he was learning Haskell, which I could barely stand to look at. ("What the heck is a comprehension?!") Today, I love Haskell too.

Why am I telling you all this? Because that guy is into Factor now, though it's still total gibberish to me.

Scala style match-case
9 points by raymyers over 2 years ago | link
cached 1 day ago
"Modules : a proposition"
8 points by raymyers over 2 years ago | link | top
cached 1 day ago
Perhaps modules should be valid containers. Thus instead of introducing a new syntax foo@a, we can use (foo 'a) and foo!a using sugar already in place. (I realize I am not the first person to say that.) I also would not like having to use mdef and m= within a module. Ideally, I should just use def, mac, and = as normal and export the symbols I want visible from outside.

    (module foo (export a bar)
      (= a 'in-top)
      (def foo (x) (+ x 1))
      (def bar (x) (+ x 1))
      (pr a))
    (prn foo!a)
    (foo!bar 0)
    (= bar foo!bar) ; an import.
    (= a2 foo!a)    ; a qualified import.
This could all be implemented as an optional library, except for those pesky macros. And of course, we do need a module system with adequate macro support.
"premature optimizations in Arc"
8 points by raymyers over 2 years ago | link | top
cached 1 day ago
Minimizing the number axioms is good. Minimize the number of convenience macros is a different proposition. Most conditionals and closures don't need anaphora, so when I see the plain if or fn I know not there's nothing funny going on. The anaphoric versions tell me I need to look for the it/self references before I'll understand what I'm reading.

Other things we shouldn't do include eliminating let in favour of the more general with, and then eliminating with in favour of the more general withs.

Of course, (withs (a (foo) b (bar a) c (baz b)) ... ) is really just:

    ((fn (a) ((fn (b) ((fn (c) ... ) (baz b))) (bar a))) (foo))
So we could lose withs too...
Parser combinator library for trees
7 points by raymyers over 2 years ago | link
cached 22 days ago
"Binary Search Trees in Arc"
7 points by raymyers over 2 years ago | link | parent | top
cached 4 days ago
Ask and ye shall receive. http://ray.codezen.org/wiki/doku.php?id=binary-search-tree
"Binary Search Trees in Arc"
7 points by raymyers over 2 years ago | link | parent | top
cached 4 days ago
Actually yes, in Haskell it is the same. Lazy evaluation means you could take the 4th element of a map over an infinite list. For example: "map (*2) [1..] !! 4"
"Will Arc ever be as fast as CL?"
6 points by raymyers over 2 years ago | link | parent | top
cached 12 days ago
Since Scheme and CL are both specifications, it would be more meaningful to ask "Is MzScheme slower than SBCL?", for instance.
Sort by: Relevance | Points | Date Posted