A modern programming language that makes developers happier.

kotlinlang

Hey <@U4H0M349G>
For some reason this snippet of code is not compiling for me, it fails the += operator.
I am using it from:
<https://www.http4k.org/cookbook/typesafe_http_contracts/>

```"Unresolved reference. None of the following candidates is applicable because of receiver type mismatch"```
I wonder if the issue is me injecting also other things into the handler that returns an HttpHandler

Attempted API:
Get a random generated test:
```api/v1/test ```
Get a specific test:
```api/v1/tests/123132```

I resolved it by doing this:
```"/test" / Path.string().of("testId", "A Specific Test") meta {} bindContract Method.GET to handler(injectedService)```
```handler(injectedService: InjectedService) = {
        test: String? -> { _: Request ->  internalHandler(injectedService).invoke(test)
}}```
I wonder if this is the right way to do this…

Also now I get this route only for
```api/v1/test/{testId}```
But get 404 on
```api/v1/test/```

That is the right way to do it - the compile error will happen if you bind to a function that doesn't take the string (which doesn't need the ? Btw). 

As for the match, the 404 will probably be because it's trying to match a handler without the path Param (will need to check)

So if there is a parameter then inherently it’s a required parameter? (not optional)

That would follow yes. Afk at the mo, but if you add another route without the Param and it matches then it will be the route matching algorithm  in concert with the behavuour of getting path params from the actual underlying Uri object 

Yup, seems it works if I add it as a separate path.

Is this an issue?
Should it be possible to have an optional trailing parameter and passing it as nullable?

It’s weird to make two separate paths/handlers for same path with and without a trailing parameter.

By the way i’m working with contracts and bindContract