Mirror of forum.nim-lang.org

234 :: Type mismatch with seq[tuple]

• caio (orginal) [2013-09-10T15:20:02+02:00] view original

  Sorry if this is a noob question, but I dug into documentation and I couldn't find answers for this problem I'm having.

  Can anyone help?

  type
      TView = proc(name: string): string {.cdecl.}
      TPattern = tuple
          prefix: string
          view: TView
      TPatterns = seq[TPattern]
  
  proc foobar(name: string): string =
      return "<b>" & name & "</b>"
  
  var patterns: TPatterns
  
  patterns = @[
      (prefix: "/", view: foobar)
  ]
  # Error: type mismatch:
  # got (seq[tuple[prefix: string, view: proc (string): string]])
  # but expected 'TPatterns'
  Run

---

• leledumbo (orginal) [2013-09-10T16:53:19+02:00] view original

  Don't you miss {.cdecl.} in foobar?

---

• caio (orginal) [2013-09-10T18:01:56+02:00] view original

  Yes, my bad. In fact this isn't my real problem, I changed the example to be more clear. Consider the following code:

  type
      TResponse = ref object {.inheritable.}
      TStringResponse = ref object of TResponse
          text: string
      TView = proc(name: string): TResponse {.cdecl.}
      TPattern = tuple
          prefix: string
          view: TView
      TPatterns = seq[TPattern]
  
  proc home(name: string): TStringResponse {.cdecl.} =
      return TStringResponse(text: "<b>" & name & "</b>")
  
  var patterns: TPatterns
  
  # Error: type mismatch:
  # got (seq[tuple[prefix: string, view: proc (string): TStringResponse{.cdecl.}]])
  # but expected 'TPatterns'
  patterns = @[
      (prefix: "/", view: home)
  ]
  
  for p in patterns:
      echo(p.view("Home!").text)
  Run

  In fact, "home" returns TStringResponse that inherits from TResponse. Isn't this expected to work?

---

• Jehan (orginal) [2013-09-10T19:04:13+02:00] view original

  You can fix part of the problem by casting home to TView, i.e.:

  
  patterns = @[
      (prefix: "/", view: TView(home))
  ]
  Run

  The cast works because (in my experience, I haven't seen it documented anywhere) Nimrod allows covariance for results. You do have to make it explicit, though.

  Note that in the last part of your code, p.view("Home!") will return a TResponse rather than a TStringResponse result, which doesn't have a text attribute. You can downcast to a TStringResponse for the purpose of this example, of course:

  
  for p in patterns:
      let resp = p.view("Home!")
      if resp of TStringResponse:
          echo TStringResponse(resp).text
  Run

  More generally, you probably want methods that work appropriately for each subtype of TResponse.

---

• caio (orginal) [2013-09-10T19:41:52+02:00] view original

  These lines looks very strange to me:

  let resp = p.view("Home!")
  if resp of TStringResponse:
      echo TStringResponse(resp).text
  Run

  I need to cast resp to TStringResponse even though "resp of TStringResponse" being true?

---

• Jehan (orginal) [2013-09-10T20:06:28+02:00] view original

  That's the runtime type that the compiler doesn't know about, so it can't make the decision at compile time.

  Edit: Note that this is just an ad-hoc hack. In practice, you'll want to use methods in conjunction with subtyping, e.g.:

  
  method printme(self: TResponse) =
      echo "Base type, nothing to see here."
  
  method printme(self: TStringResponse) =
      echo self.text
  
  for p in patterns:
      p.view("Home!").printme
  Run

---

• caio (orginal) [2013-09-10T20:56:48+02:00] view original

  Okay, it worked fine!

  Now my only concern with all this code that we discussed is the need to cast TView:

  patterns = @[
      (prefix: "/", view: TView(home))
  ]
  Run

  Since this was already done in tuple definition:

  TPattern = tuple
      prefix: string
      view: TView
  Run

  but.. it works, thanks!

---

• Araq (orginal) [2013-09-10T21:54:08+02:00] view original

  1. There are some bugs wrt inheritance that I'm fixing right now.
  2. There is nothing confusing here: TView returns TResponse but your 'home' returns a TStringResponse. The types do not match.
  3. It's yet another bug that the compiler allows co/contravariance for proc type conversions. So ... don't use this solution.

  4. Use this solution:

  
  type
      PResponse = ref object {.inheritable.}
      PStringResponse = ref object of PResponse
          text: string
      TView = proc(name: string): PResponse {.cdecl.}
      TPattern = tuple
          prefix: string
          view: TView
      TPatterns = seq[TPattern]
  
  method getText(r: PResponse): string = ""
  method getText(r: PStringResponse): string = r.text
  
  proc home(name: string): PResponse {.cdecl.} =
      return PStringResponse(text: "<b>" & name & "</b>")
  
  var patterns: TPatterns
  
  patterns = @[
      (prefix: "/", view: home)
  ]
  
  for p in patterns:
    echo(p.view("Home!").getText)
  Run

  But I wouldn't use inheritance at all. ;-)

---