Macros

Post #44,570 by wharris2 7/5/02 8:16:15 PM Reply	Macros Maybe I've had too much experience with m4 and C-style macros, but whenever I think a macro is the best way to do something, it usually comes back and bites me in the butt. Famous last RPG quotes: "I'll just shoot this fireball down the dungeon passageway..."
Post #44,577 by neelk 7/5/02 8:58:57 PM Reply	Not just macros! If you've had experience with C and M4 macros, you've had too much experience with them. :) They just suck. The various branches of the Lisp family tree -- Common Lisp, Dylan, Scheme -- all have macro systems that don't cause crippling spinal trauma. But macros are really besides the point: they came up mostly because I wanted an example of a kind of abstraction that regular procedural abstraction doesn't work all that great at, and not surprisingly the obvious examples come from languages that have non-procedural ways of building abstractions. If I have the tools to capture an abstraction, I'll be more likely to keep an eye out for them. For example, I really like Perl 6's built-in grammar support. Writing recursive descent parsers by hand isn't actually hard, per se. It's just that the code comes in a very stereotyped form and it's a great idea to sugar away the repetitious bits, so that when you are debugging you don't have to first figure out whether an error happened because you made a conceptual error or just because you mistyped some boilerplate. Another example is Ocaml's module system. It is, honestly, the closest I have ever seen a language come to making software out of interchangeable parts. The basic idea is to make linking part of the module language: you can write code that is parameterized on the modules it uses. Parameterized modules (called functors) take some modules as arguments, and then build a module. For example, you can build a case-insensitive string map like this: module CaseFoldCmp = struct type t = string let compare a b = compare (String.lowercase a) (String.lowercase b) end \t module CaseFoldingMap = Map.Make(CaseFoldCmp) And just like that, you have a case-folding map module that has all of the operations of the standard library's Map module. This is very cool.
Post #44,588 by wharris2 7/6/02 2:00:04 AM Reply	Re: Not just macros! To me, that's not clear at all. Where did A and B come from? Vapor? Assumed arguments to functions? Some sort of object-oriented stuff that I haven't wrapped my mind around yet?
Post #44,593 by neelk 7/6/02 5:44:28 AM Reply	Re: Not just macros! That's a function definition -- a and b are the arguments. Caml has a funny syntax. Here's an annotated version, with comments (* like this ). module StringCmp = struct type t = string ( This is like a C typedef ) ( This is a function definition. 'let compare a b = <foo>' declares a function that takes two arguments a and b. The <foo> expression after the = is the function body. Function calls don't use the 'f(x, y)' syntax. Instead, Caml uses simple juxtaposition: 'f x y' instead. ) let compare a b = compare (String.lowercase a) (String.lowercase b) ( This call to compare calls the generic comparison function, and rebinds it locally in this module. (String.lowercase s) will return a lowercase version. So what we are doing is lowercasing both args and then calling the generic compare, to get a case-insensitive comparison. *) end

Welcome to IWETHEY!