There are several ways you might login in news.arc, and correspondingly, there are specific bits of code for each of those cases: when you click the top-right login link (see topright in news.arc), when you try to vote (see newsop vote), when you try to submit (see submit-login-warning), when you try to comment (see comment-login-warning), when you try to reply (see newsop reply), etc.

What do these have in common? The login-page function, defined in app.arc:

  (def login-page (switch (o msg nil) (o afterward hello-page))
    (whitepage
      (pagemessage msg)
      (when (in switch 'login 'both)
        (login-form "Login" switch login-handler afterward)
        (hook 'login-form afterward)
        (br2))
      (when (in switch 'register 'both)
        (login-form "Create Account" switch create-handler afterward))))

  ; Need this because can create users on the server (for other apps)
  ; without setting up places to store their state as news users.
  ; See the admin op in app.arc.  So all calls to login-page from the 
  ; news app need to call this in the after-login fn.

  (def ensure-news-user (u)
    (if (profile u) u (init-user u)))

You still need to make sure ensure-news-user behaves the same way (i.e., returns the proper user) so that the functions that use ensure-news-user don't break. Shouldn't be too bad to add a ++ in there, then just return the user.

I'll interpret "it is a new day" as "it's a new day between now and when they last logged in" (which isn't necessarily 24 hours, just a new date). This requires knowing when they last logged in. Probably the easiest way to get this would be adding some new info to the profile template, and recording it on each login (an action we're doing now anyways, so not a big deal). Look for deftem profile and add a line to it:

  (deftem profile
    id         nil
    name       nil
    created    (seconds)
    ...
    last-login (date) ; default last-login = whenever the new profile was made
    ...
    delay      0)

  ; These two functions take in the today argument (i.e., (date)), since
  ; otherwise you might do the equivalent of
  ;
  ;   (it-is-a-new-day u (date))
  ;   ...
  ;   (update-last-login u (date))
  ;
  ; But (date) might change between the times when you make the two function
  ; calls, so it should be bound outside, like
  ;
  ;   (let today (date)
  ;     (it-is-a-new-day u today)
  ;     ...
  ;     (update-last-login u today))

  (def it-is-a-new-day (u today)
    (with ((new-y new-m new-d) today
           (old-y old-m old-d) (uvar u last-login))
      (or (> new-d old-d)                   ; e.g., Apr 15, 2010 -> Apr 16, 2010
          (> new-m old-m)                   ; e.g., Apr 30, 2010 -> May 01, 2010
          (> new-y old-y))))                ; e.g., Dec 31, 2010 -> Jan 01, 2011

  (def update-last-login (u today)
    (= (uvar u last-login) today))

  (let old ensure-news-user
    (def ensure-news-user (u)
      (with (u (old u) today (date))
        (when (it-is-a-new-day u today)
          (++ (karma u)))
        (update-last-login u today))
        u)) ; return the result of old-ensure-news-user

Does ensure-news-user get run on page load as part of the code that checks whether their logged in or not? From a cursory look at the code, it didn't appear to work that way.

the date comparison could be easier:

  (deftem profile
      ...
      last-login (datestring))

   (let old ensure-news-user
      (def ensure-news-user (u)
        (with (u (old u) today (datestring))
          (when (> today (uvar u last-login))
            (++ (karma u)))
          (update-last-login u today))
          u))

  (unless (is (date) (uvar u last-login))
    (++ karma.u)
    (= (uvar u last-login) (date)))

  (mac updating(place expr . body)
    (w/uniq rhs
      `(let ,rhs ,expr
         (unless (is ,place ,rhs)
           (= ,place ,rhs)
           ,@body))))

  ..
  (updating (uvar u last-login) (date)
    (++ karma.u))

  (mac updating(place ? expr t iff 'is . body)
    (w/uniq rhs
      `(let ,rhs ,expr
         (unless (,iff ,place ,rhs)
           (= ,place ,rhs)
           ,@body))))

  (mac firsttime(place . body)
    `(updating ,place
        :body
          ,@body))

Now you can run several kinds of test-and-update:

  (firsttime user!loggedin
     (prn *welcome-message*))

  (updating (uvar u last-login) (date)
    :body
      (++ karma.u))

  ; track largest value seen so far
  (ret max 0
    (each elem '(1 3 2 6 5)
      (updating max :iff > elem
        (prn "max now: " max))))

  max now: 1
  max now: 3
  max now: 6
  6

  (mac updating(place ? expr t iff 'is . body)
    (w/uniq rhs
      `(let ,rhs ,expr
         (unless (,iff ,place ,rhs)
           (= ,place ,rhs)
           ,@body))))

  (def fn-updating (current-val setter-getter new-val comparator body)
    (unless (do.comparator current-val new-val)
      (.new-val:do.setter-getter)
      (do.body)))
  
  (mac updating (place ? expr t iff 'is . body)
    (let (binds val setter) setforms.place
      `(withs ,binds
         (fn-updating ,val (fn () ,setter) ,expr ,iff (fn () ,@body)))))

The ssyntaxes .foo and !foo are short for get.foo and get!foo. Also, a:b ssyntax is handled before a.b ssyntax, giving the : lower precedence.

That means (.new-val:do.setter-getter) compiles as though it's ((get new-val) ((do setter-getter))), which makes it a roundabout way to accomplish ((do.setter-getter) new-val) with one less pair of parentheses, one less character, or (by my count) one less token.

It's really sort of silly in this case, since you save on so little while rearranging so much. In its favor, he (.a:b ...) idiom makes a bit more sense when it's a field/element access like (!width:get-rect ...) or (!2:setforms ...). It's especially helpful when it's part of a big chain of composed forms like (.a:b:.c:.d:e ...).

In my own code, including Lathe, I define this:

  (def call (x . args)
    (apply x args))

I remembered talking about this once and found the comment: http://arclanguage.org/item?id=11697

  a."b".c.d.g

Of course, if "b" were a symbol instead of a string, it would just be "a!b.c.d.g".

  (define (has-ssyntax-char? string i)
    (and (>= i 0)
         (or (let ((c (string-ref string i)))
               (or (eqv? c #\:) (eqv? c #\~) 
                   (eqv? c #\&)                
                   (eqv? c #\%)                
                   ;(eqv? c #\_) 
                   (eqv? c #\.)(eqv? c #\!)))
             (has-ssyntax-char? string (- i 1)))))

  (define (expand-ssyntax sym)
    ((cond ((or (insym? #\: sym) (insym? #\~ sym)) expand-compose)
           ((or (insym? #\. sym) (insym? #\! sym)(insym? #\% sym)) expand-sexpr)
           ((insym? #\& sym) expand-and)
       ;   ((insym? #\_ sym) expand-curry)
           (#t (error "Unknown ssyntax" sym)))
   sym))

  (define (build-sexpr toks orig)
    (cond ((null? toks)
           'get)	    
          ((null? (cdr toks))
           (chars->value (car toks)))
          (#t
           (list (build-sexpr (cddr toks) orig)
                 (cond ((eqv? (cadr toks) #\!)
                        (list 'quote (chars->value (car toks))))
                       ((eqv? (cadr toks) #\%)
                         (list 'string (list 'quote (chars->value (car toks)))))
                       ((or (eqv? (car toks) #\.)(eqv? (car toks) #\!)(eqv? (car toks) #\$)(eqv? (car toks) #\%))
                         (err "Bad ssyntax" orig))
                       (#t 
                       (chars->value (car toks))))))))

  arc> (= test (obj "a" "my a val" "b" "my b val"))
  #hash(("a" . "my a val") ("b" . "my b val"))

  arc> test%a
  "my a val"

  (deftem profile
  ...
  karmadate nil
  ...
  )

  (def process-comment (user parent text ip whence)
  ...
         (day-karma user)
         whence)))

  (def day-karma (u)
    (when (~iso (date) (uvar u karmadate))
      (++ (karma u))
    (update-karmadate u)))

  (def update-karmadate (u)
    (= (uvar u karmadate) (date))
    (save-prof u))

  (unless (is (date) (uvar u last-login))
    (++ karma.u)
    (= (uvar u last-login) (date)))

In this case, "karma.u" expands to (karma u), which is a macro that looks up the users karma. Functions applied to single arguments are extremely common in arc, so it is quite useful to have an abbreviation.

Other ssyntax include:

  a!b -> (a 'b)
  ~a -> (no a)
  a~b -> (compose a (no b))
  a:b -> (compose a b) ;(a:b c) is equivalent to (a (b c))

  <a href="http:..." title="Agreed.">Ask so-and-so: ...</a>

Using spanclass the spacing is conserved, but I only get some attributes onto the comment, but not hover. Here's where I am working, with a spanclass comref that only seems to be able to override the color of the subtext class.

  (def commentlink (i user)
    (when (cansee user i) 
      (pr bar*)
      (tag (a href (item-url i!id))
        (let n (- (visible-family user i) 1)
          (if (> n 0)
              (spanclass comref
              (do (pr (plural n "comment"))
                  (awhen (and show-threadavg* (admin user) (threadavg i))
                    (pr " (@(num it 1 t t))"))))
              (pr "Add comment"))))))

I often find myself clicking through to comments on HN and reddit, just curious to see what the highest rated one is. -I thought it be nice to be able to save the trip.