Anyway as I mentioned before I'm using readable sweet-expressions for
a ridiculously large project (whose copyright is currently slightly
contestable - it's definitely my code (except for readable/kernel.scm
and some SRFI implementations) using my spare time and my own stuff,
but it involves IC digital logic design, which is my RL work, so I
probably want to get a waiver from my employer just to be paranoid).

So far here are my experiences...

Using SUBLIST after a 'define for anything other than either 'begin or
'cond is a recipe for confusion:

define foo(x y) $ let ((z compute-something(x))) ; don't do this
!  whatever

Using SUBLIST after a 'define for 'cond is actually quite cute, and it
works well for *nested* cond in particular:

define foo(x y) $ cond
! berber?(x) $ cond
!   catfish?(y) $ blast-it x y
!   #t          $ kaboom x y
! rufruf?(x) $ reduce-to-little-bits x y
! #t         $ incinerate x y

Using SUBLIST for let variables is cute:

let
! $ single $ compute x y z
! use single
let
! \\
!   double-x $ compute x y z
!   double-y $ compute y z x
! use double-x double-y

You don't need 'when.  You might want 'unless, but 'not is just a few
more characters away, and 'unless gets a lot less attractive with the
SUBLIST-begin idiom:

if pred?(x) $ begin
  do-something()
  do-another-thing()

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Readable-discuss mailing list
Readable-discuss@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/readable-discuss

Reply via email to