1 Arguments
+
+In Emacs lisp, keyword arguments must be passed in the same order as they were
+defined in, so ((lambda (a &key b c) (+ a b c)) 1 3 :b 2) will preduce an
+error, because b was passed as last argument but was defined as second argument.
+
((lambda (a b) (+ a b)) 1 2) ;; 3 +((lambda (a &key b) (+ a b)) 1 :b 2) ;; 3 +((lambda (a &key b) (+ a b)) :b 2 1) ;; error ++
+But if mulitiple keyword arguments are defined, their ordering does not matter. +
+((lambda (a &key b &key c &key d) (+ a b c d)) 1 :d 4 :c 3 :b 2) ;; 10 ++
+It is even possible to have a non keyword argument bewtween keyword arguments +and when calling, switch the order. +
+((lambda (a &key b c &key d) (+ a b c d)) 1 :d 4 3 :b 2) ;; 10 +((lambda (a &key b c &key d) (+ a b c d)) 1 :d 4 :b 2 3) ;; error ++
+However somehow it is not possible to flip the ordering at the first argument +
+((lambda (a &key b) (+ a b)) 2 :b 1) ;; 3 +((lambda (a &key b) (+ a b)) :b 2 1) ;; error +((lambda (&key a b) (+ a b)) :a 2 1) ;; 3 +((lambda (&key a b) (+ a b)) 1 :a 2) ;; error ++
+So it seems, positional arguments have to be at the exact position they were +defined in, but keyword arguments can appear in any order, but at the places +where keyword arguments have been defined. +
+1.1 Idea
++Every argument can be set using keys, but keyword arguments always come strictly +after positional arguments +
+ +((lambda (a b c d)) 1 2 3 4) ;; ok +((lambda (a b c d)) 1 2 :c 2 :d 1) ;; ok +((lambda (a b c d)) 1 2 :d 1 :c 2) ;; ok +((lambda (a b c d)) :d 1 1 2 :c 2) ;; error, keyword arguments must come last +((lambda (a b c d)) 1 2 :c 2 :d 1 :a 2) ;; error, 'a' was passed two times + +((lambda (a b c d)) 1 2 :d 1) ;; error, c was not passed, but does not have a default value +((lambda (a b c :default 10 d)) 1 2 :d 1) ;; okay again ++
+The drawback then is that you can never pass a keyword as a positional argument, +because it will always try to assign the next argument to the variable defined +by the keyword. You could still pass it as a keyword argument though. This is +especially annoying because we want to use keywords as type identifiers. +
+ +(= (type "hello") :string) ++
((lambda (i-wanna-get-a-kw)) :hey) ;; error, unmatched value for keyword argument +((lambda (i-wanna-get-a-kw)) :i-wanna-get-a-kw :hey) ;; this would work again ++
+Other Idea is to mark the place in the parameter list where keyword argumetns +start and arguments before that are positional and will not be stuffed into +key-value pairs and arguments after that will be keyword arguments +
+ +<lambda list> -> <positional argument>* + [:keys ( <keyword arguments> [:defaults-to <value>])*] + [(:rest <rest argument>)|(:body <body argument>)] ++
(= (type "hello") :string) ;; this will work again because (=) does + ;; not use keyword arguments + ((lambda (i-wanna-get-a-kw)) :hey) ;; would work because of the same reason + + (define fun + (lambda (:keys a b c d) + (+ a b c d))) + + (fun 1 2 3 4) ;; okay + (fun 1 2 :d 3 :c 4) ;; okay + (fun 1 2 :d 3 :c 4 :a 2) ;; error, 'a' was passed two times + (fun :c 1 :b 2 :d 3 :a 4) ;; okay + (fun :c 1 :b 2 :d 3 4) ;; error, positional argument after keyword + ;; and fun does not accept rest parameter + + (define fun2 + (lambda (:quoted op a b :keys c d :rest r) + (print r) + (op a b c d))) + +>> (fun2 * 1 2 :c 3 :d 4 "this" "can" :be "whatever") +("this" "can" :be "whatever") +24 + + +>> (define print-before-eval (lambda (:body expr) + (print expr) + (eval expr))) +>> (define r (print-before-eval (+ 1 2 3))) +(+ 1 2 3) +>> r +6 + ++
+Wait this does not work either because you won't be able to pass keywords into +rest. +
+ ++Unrealated Idea: Distinguish between functions and macros +
+ ++The difference is really simple: +
+-
+
- Function
- like a lambda, but no argument is automatically quoted + +
- Macro
- like a lambda, but every argument is automatically quoted + +
+This is important, because a macro should not introduce a new environment, but +use the one it lives in. +
+ +>> (define print-before-eval (macro (:rest expr) + (print expr) + (eval expr)) + ++
1.2 the actual problem
++We have some requirements to the arguments: +
+-
+
- positional arguments (always required, no default value) + +
- keyword arguments (always come after positionals), can be not passed if there +is a default value + +
- We want to be able to have a rest paramter, where everything is dumped in to +that exceeds the other parameters + +
+The problem is, we have no way of knowing if the current keyword we are + reading is still part of the keyword block or part of the rest paramter. +
+ ++Consider: +
+ +>> (define fun (lambda (a b :key c d :defaults-to 4 :rest) nil)) +>> (fun 1 2 :c 3 :d 5) ++
+What should this be evaluated to? +
+ +| + | a | +b | +c | +d | +rest | +
|---|---|---|---|---|---|
| v1 | +1 | +2 | +3 | +5 | +nil | +
| v2 | +1 | +2 | +3 | +4 | +(:d 5) | +
+It is ambiguous. It is however important to note that this can only happen when +there are optinal keyword arguments (keyword arguments with default values). +Otherwise we could always know which variables are set and wich have not been +set to see if we are in an errornious state. +
+1.3 Solution
+
+We can resolve that problem by always making the the decision of chosing v1
+between v1 and v1. This means, when we are expecting to read kwargs, and we
+encounter an kwarg, try to apply it (this can fail, for two reasons:
+
-
+
- The keyword has no following value + +
- The keyword is not a keyword argument in the funciton + +
+), if it fails treat it as part of the rest arguments, and read all the +following arguments into the rest arguments, or if it works, use it as the +keyword argument. +
+1.4 Implementation
+typedef struct { + char* docstring; + char** positional_arguments; + struct { + char* identifier; + Ast_node* default_value; // will be nullptr if no defalut value was declared + }* keyword_arguments; + char* rest_argument; // will be nullptr if no rest argument is declared + Ast_Node_array_list body; +} lambda; ++