Although I don't recall for HtDP, the convention I've seen in Racket and docs generally is to use square brackets for an optional argument in the sense you mean: A single argument that's present or not. For instance:
;; ArgType [OptionalArgType] ArgType -> ResultType Whereas I would read "foo ..." as "zero or more": 0, 1, 2, .... +inf But your optional argument example is really "zero or one" (not more). A cheat sheet: Function/syntax sigs in docs: [zero-or-one] zero-or-more ... Regular expressions: zero-or-one? zero-or-more* p.s. When it comes to ONE-or-more in things like regexps, match patterns, macro syntax rules, and docs, there's more variety. Sometimes there's no explicit one-or-more notation so you have to "fake it" as: foo0 foo1 ... ;; e.g. syntax-rules, syntax-case But sometimes you'll find notation like: foo+ ;; e.g. regexp foo ...+ ;; e.g. match, syntax-parse On Fri, Aug 23, 2013 at 12:28 AM, Alexander D. Knauth <alexan...@knauth.org> wrote: > Right now I'm using Intermediate Student Language, not Racket, because I > don't know Racket and I've been taking Introduction to Systematic Program > Design - Part I online, which is based on HtDP, or How to Design Programs. > > I was wondering if I could define a function with optional arguments, and I > figured out how to define them, but since they accept different numbers of > arguments, the signature would be different depending on how many arguments > it's called with. So how do I write the signature? > > Would it be something like this, with a "one of"?: > ;; one of: > ;; FirstArgumentType SecondArgumentType ... OptionalArgumentType ... -> > ResultType > ;; FirstArgumentType SecondArgumentType ... -> ResultType > > Or would it be something like this, with a question mark?: > ;; FirstArgumentType SecondArgumentType ... OptionalArgumentType? ... -> > ResultType > > Or should it be something else entirely? > > The particular example I'm thinking of is an abstract fold function that has > an optional argument (a function) for the contribution of the first: > (check-expect (fold + 0 (list 1 2 3)) 6) ;sum, without optional > argument > (check-expect (fold + identity 0 (list 1 2 3)) 6) ;sum, with identity as > the optional argument > (check-expect (fold + string-length 0 (list "a" "bc" "def")) 6) > ;total-string-length > > (define fold > (local [(define (fold-with-cof comb cof base lox) > (foldr comb base (map cof lox))) > (define (fold--args args) > (cond [(= 3 (length args)) (apply foldr args)] > [(= 4 (length args)) (apply fold-with-cof args)] > [else > (error "fold: expects 3 or 4 arguments, but found " > (length args))]))] > > (compose fold--args list))) > > > You could also design a weird function that does completely different things > depending on what the arguments are, like this: > > (check-expect (foo "string" 2 6) "ring") > (check-expect (foo 1 2 3 4 5) 15) > (check-expect (foo 9 empty true) (list false true false)) > > (define foo > (local [(define (fold--args args) > (cond [(and (or (= 2 (length args)) > (and (= 3 (length args)) > (number? (third args)))) > (string? (first args)) > (number? (second args))) > (apply substring args)] > [(andmap number? args) > (apply + args)] > [else > (map empty? args)]))] > > (compose foo--args list))) > > > How would I write the signature for a weird function like this? Or should > such a weird function not even exist? > > > ____________________ > Racket Users list: > http://lists.racket-lang.org/users > ____________________ Racket Users list: http://lists.racket-lang.org/users
